Vega Lets a Rolling Ball Pick the Answer, With a Frozen Qwen3.5 Doing the Reading

Independent developer Nandakishor M has open-sourced Vega, a decision model that never generates text and never trains its language model. Published on October 10, 2026, Vega ships as the vegaml Python package with source, package and weights under the Apache 2.0 license. It takes a piece of text or an image plus a question whose answer type is fixed in advance, such as a label, a rating or a yes/no judgment, and returns one of the allowed answers with a calibrated probability, a set of answers it is prepared to stand behind, and a flag for cases where it would rather abstain.

Several labs have released typed decision models in recent weeks. Vega’s distinguishing feature is the mechanism it uses to reach an answer: a small simulated physical system rather than a classifier head.

A hard line between reading and deciding

Vega splits the work into two halves with an absolute boundary. On one side sits a frozen Qwen3.5-0.8B, pinned by a SHA-256 hash so that a silently updated base model is refused rather than used. It is read at layers 13 and 19 of its 24 layers, and the forward pass stops right after the deepest layer being read. The layers above it and the language-modeling head never run, so nothing in the decision path can produce a token.

On the other side is the trained engine, which the author describes as about 55 to 57 MB and 14.3 million parameters for the default model. A larger option swaps in a frozen 4B reader with a 30.9 million-parameter, 124 MB engine. Freezing the backbone, the author writes, keeps the trainable part small enough to fit on a laptop, train in hours, and debug as “a 64 dimensional dynamical system, not 800 million weights.”

The situation, the question and every candidate answer are written into a single prompt in a fixed format, read once. Vega then averages different stretches of the resulting token vectors to get separate representations for the situation, the question and each answer, and keeps the final token’s hidden state as an end-of-prompt signal.

Valleys built from the answers

Each candidate answer is turned into a Gaussian well with its own center, depth and width, set inside a quadratic bowl that keeps the system bounded. A particle is given a starting position and momentum in a 64-dimensional space and then stepped for a fixed budget of 12 steps by a damped, symplectic integrator. The engine sets its own step size and friction per step, and a small state-space model adds a bounded force based on the trajectory so far. Where the particle comes to rest is the answer.

Because the wells come from the option text, the answer set is not frozen at training time. Rating options are laid out along a line, so a 3 sits physically between a 2 and a 4, and near-synonymous options produce overlapping wells. The fixed step budget makes latency predictable, and the result is deterministic, with no sampling or seed.

Probabilities come from a Boltzmann distribution over the wells, and the temperature is predicted per decision from how the particle stopped: its leftover speed, its distance from the nearest valley floor, and how much of the budget it used. Two flags ride along with every answer: abstain, when confidence falls below a floor fitted on held-out data, and unbound, when the particle settled far from every valley, signaling a question outside the model’s training.

Long inputs and images

Vega accepts up to 73,728 tokens of context. A long document is encoded once and shared across multiple questions, split into sixteen separately summarized pieces so late evidence still reaches the decision, and refused outright if it does not fit rather than silently truncated. Since the Qwen3.5 backbone is multimodal, an image can replace the situation text in the same prompt format.

Selective wins, stated as such

The author compares Vega 0.8B against the hosted Jev 1.13.0 on identical items and frames the table as a selected set. On 800 phishing-screening emails Vega scores 75.4 against 61.9 and catches 252 of 400 phishing messages against 99. Median latency for one decision is listed at 267 ms against 591 ms. The post says the hosted model “leads on most of the benchmarks I ran,” particularly reranking and multi-step reasoning over long documents.

Users with labeled examples can also fit a small head on the same frozen features. The author warns that such a head carries no calibration or abstain flag, so the library returns a cross-validated accuracy report and flags heads that land at or below chance.

Installation is pip install vegaml, with vegaml.load() for the 0.8B model and vegaml.load("4b") for the larger one, and a Colab notebook runs the full system on a single T4 GPU.