Bespoke Nimble

Bespoke Nimble is Bespoke Labs' attempt to publish everything behind a Jev-style decision model: the data, the weights, and the training recipe. Where Jev is a closed System One model you call over an API, Nimble is a 9B model you download and run yourself. You give it some text and a flat schema, and it returns a typed decision: for each question, the answer it picked and the probability of every allowed answer. It does not write reasoning first, so it is fast, and it does not generate JSON, so there is nothing to parse. The first-party repository was created on 2026-09-18, and GitHub listed 1,111 stars and 80 forks on 2026-09-21. Note that the repository publishes no license file as of that date; the weights live at bespokelabs/Bespoke-Nimble-9B, and anyone planning to ship it commercially should establish terms with the lab first.

How It Works

The interesting part is the training method, which the lab calls contrastive data curation. Instead of collecting examples with probabilities attached, they construct pairs of otherwise identical samples where one fact is changed just enough to flip the correct answer. The model is then forced to learn which single piece of evidence should change a decision. Training is a LoRA fine-tune of Qwen3.5-9B on the answer tokens only, over 2,676 curated examples drawn from 10 categories and generated synthetically. There is no reinforcement learning in this release.

Results

On the lab's own 324 held-out examples, Bespoke-Nimble-9B matched the reference labels 90.1% of the time, against 66.4% for its untuned Qwen3.5-9B base and 93.2% for Jev 1.13.0. These are the lab's numbers on the lab's eval, and the README says plainly that no standard benchmark exists for this kind of model, so it may well be worse on tasks outside its training domains. Treat the score as evidence that the recipe works, not as a general ranking.

Serving Model

• One answer token per question: each allowed answer has a one-token code, and the scorer reads the model's logits for those codes rather than generating text.
• Calibrated by construction: logits go through softmax, so probabilities add up to 1 across the answers you supplied. Your code assembles the output.
• Parallel scoring: on a Mac, ParallelScorer reads the shared context once and then scores every field in parallel. The CUDA path scores each field separately.
• Apple Silicon or NVIDIA: without quantization the 9B weights alone are about 18 GB, and the merge step needs extra RAM and disk.

Use Cases

• Routing: declare destinations and the conditions that select them, and get back the chosen destination with a probability.
• Policy checks and ratings: ordered levels with clear criteria become a typed decision plus the probability of each level.
• Agent evaluation: score a run against yes/no questions without paying for a full generation per question.

Limitations matter here. Nimble accepts text only, picks only from the answers you supply, and cannot return a nested schema or a span lifted from the input. The schema must be flat, an enum field can hold 1 to 26 choices, and a prompt is capped at 2,048 tokens including the schema. Probabilities are not accuracy guarantees: a 0.9 does not mean 90% correct, so test any threshold on your own data and add a "no match" option if none of your answers may fit. Because fields are scored independently, your code has to enforce consistency between them.

Pricing

There is no hosted API and no paid tier published as of 2026-09-21.

Getting Started

git clone https://github.com/bespokelabsai/nimble.git nimble
cd nimble
python3.12 -m venv .cache/venvs/nimble
source .cache/venvs/nimble/bin/activate
python -m pip install torch==2.8.0 -r requirements/training.txt

The bundled download script pulls bespokelabs/Bespoke-Nimble-9B, merges the adapter when the release ships one, and records the resolved revision so the scoring prompt and the model stay in sync.

Frequently Asked Questions

Is this a Jev clone?

No. The README states the lab did not distill from Jev; they used Jev only to evaluate. The point of publishing is to show how to curate data, train, and serve this class of model.

Can it explain its answer?

No. It does not generate reasoning, and it cannot write text of its own. If you need an explanation, pair it with a chat model and let Nimble make the call.

Does it need an API key?

For local inference, no. There is no TypeSafe or generation API key in the loop.

Alternatives

• Jev: the closed model this recipe is measured against, available as an API rather than weights.
• Qwen3.8-27B: a much larger general-purpose Qwen model for when you need generation rather than a single typed decision.
• Ternary Bonsai 2: another small, locally runnable model worth comparing on cheap classification tasks.

Tips

1. Always include a "no match" answer in each enum. The model can only choose from what you list, and a confident-looking probability is still just a normalized score.
2. Keep one question per field. Fields are scored independently and do not see each other, so cross-field logic belongs in your application code.
3. Budget memory for the merge step, not just inference. The weights are about 18 GB before quantization, and merging needs headroom on top of that.

Conclusion

Bespoke Nimble is best read as a recipe with weights attached: a two-day, open build that gets a 9B model close to a closed System One model on the lab's own eval. If you want typed, calibrated decisions running locally instead of an API round trip, it is the clearest worked example available, provided you check the licensing situation yourself before shipping.