Nimble AI Model: Train Your Own Local AI Classifier in a Weekend

A team at Bespoke Labs built a 9-billion-parameter classification model in one day and scored 90.12% on a held-out test set where TypeSafe's closed, commercial Jev model scores 93.21%. That is a 3-point gap between a weekend project and a funded company's flagship product, and it is the headline number behind Nimble, a new entrant in the fast-growing category of typed decision models: systems that answer yes-or-no and multiple-choice questions about a piece of text in one forward pass, without ever generating a sentence.

The Nimble AI model launched September 18 and hit 1,249 GitHub stars within three days, among the fastest growth this niche has seen. What makes it worth a real look is not just the accuracy number. It is the workflow underneath: Nimble ships a documented way to curate your own contrastive training data and train a classifier on categories nobody else has built, rather than locking you into someone else's fixed decision schema.

What a typed decision model actually replaces

Ask a normal chat model "is this email spam, yes or no" and it still writes out a full sentence, token by token, before you parse the words back into an answer. That is slow and wasteful for what is really a one-bit decision. Typed decision models skip the writing step. You send a schema, a set of allowed answers (yes/no, a multiple-choice list, or a numeric score), plus the text to evaluate, and the model runs a single pass and reads the probability it assigned to each allowed option directly off its internal output. It never generates free text, so it cannot hallucinate an answer outside the options you gave it.

TypeSafe's Jev popularized this pattern commercially. Nimble, and an earlier self-hosted clone called OpenJev, both build on the same idea using different open base models. Where Nimble earns its own space in this category is the second half of the pipeline: building the training data itself.

What using the Nimble AI model actually looks like

Setup starts with a standard clone and a Python 3.12 virtual environment:

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

On a Mac, that means a second Apple Silicon-specific environment using MLX, Apple's own machine learning framework, which is the detail that matters most for a solo operator without server-grade hardware: Nimble runs entirely on a Mac, no rented GPU required, something OpenJev's self-hosting path does not offer since it needs an Nvidia GPU with at least 24GB of VRAM. Linux users with a CUDA-capable Nvidia GPU get a parallel setup path instead. Either way, the 9B model's weights need roughly 18GB of memory without quantization, and Bespoke Labs recommends 64GB of RAM for the model-merging step on Mac.

Once running, a decision looks like this in code: load a scorer (MLX on Mac, CUDA on Linux), define a schema of enum or boolean fields, and call scorer.score("context text here", schema). The result comes back typed, with a probability attached to every candidate answer, not just the winning one.

Training your own categories with contrastive data curation

This is the part that separates Nimble from a simple hosted clone. The project documents a four-step process for building training data for a category it was never pretrained on:

1. Start from the decision rules in your own schema and identify which underlying facts those rules actually depend on.
2. Build paired examples that differ in exactly one "focus fact," changed by eight words or fewer, where that single change should flip the correct answer.
3. Validate both examples in a pair with separate model calls, checking that the facts are consistent and that no single piece of evidence gives away the answer on its own.
4. Generate labels by running checked rules in code, and keep a pair only when the two examples actually get different labels.

The project's own documentation puts it plainly: "From these pairs, the model learns which evidence should change its decision." That is a meaningfully different pitch than "here is a fixed decision API." It is a recipe for building a custom classifier for your own moderation policy, your own lead-scoring rubric, or your own routing logic, trained on labeled pairs rather than hand-tuned prompts.

Where it actually falls short, and who it is not for

Nimble is honest about its own limits in its own documentation, more so than most projects at this stage of hype. It accepts text only, no images, despite running on a base model that can handle them. It caps input at 2,048 tokens per prompt. It generalizes narrowly: the shipped model was trained on 2,676 curated examples across 10 categories, and the project says plainly not to expect it to handle a category outside those without retraining. A 0.9 confidence score, per the docs, "does not mean that the answer is right 90% of the time," a calibration caveat worth taking seriously before wiring this into anything customer-facing. All training labels are synthetic and model-checked rather than human-reviewed, which is a real gap for anyone planning to use this for a decision with legal or safety weight.

There is one more thing worth checking directly rather than trusting a scan of the repo: as of this writing, GitHub's API reports no license file at all on the Nimble repository, despite early coverage describing it as open source under Apache 2.0. Without a LICENSE file, the code defaults to standard copyright, meaning technically all rights reserved unless Bespoke Labs adds one. That is a meaningful difference from OpenJev, which is explicitly Apache 2.0 licensed end to end, and it is worth a direct check with the project before building anything you plan to redistribute or run commercially on top of it.

Nimble is for a technical operator who already has a specific, narrow classification job (spam filtering, lead qualification, content moderation, routing) and wants to train a model on their own labeled data instead of renting a closed API or accepting someone else's fixed category list. It is not yet the tool for someone who wants a drop-in replacement for Jev out of the box; for that, the more directly compatible option remains OpenJev, whose SDK deliberately mirrors TypeSafe's own package naming.

Sourced from Bespoke Labs' Nimble repository on GitHub, its published documentation, and GitHub's repository API, checked directly against the live repo rather than a scan snapshot.