docs › Classification models

Classification models

Pick the model that scores coins with probabilities (an open Kev model on your own machine, TypeSafe's hosted Jev with your own key, or the built-in scores), with how each one measured on dexterm's own labelled history.

Experimental. A classification model answers typed questions about one coin with a probability for every possible answer. dexterm asks two questions:

• drain_6h: will this coin be drained within 6 hours (liquidity pulled, or the price under a fifth of now)?
• outcome_6h: RUG, WIN (at least 3x on a pool that still holds $10k) or DUD over the next 6 hours.

A third set, narrative, sorts a coin into a narrative category (animal, AI, politics, celebrity, culture, tech, other).

Every answer is a model estimate: it carries the model id, the latency, the cost and a note on how its probabilities were calibrated. It is not advice and not a trade signal. Nothing here signs, trades, arms a strategy or changes a limit. The token's own text (name, symbol, description) goes through the prompt firewall first, and text that tries to steer the model (a bio that tells it what to answer) is removed before any model sees it.

The choices#

A decision model reads the coin's facts once and scores every answer in one pass, without writing text. That is why it can be fast enough to score a whole screener.

The default is heuristic: dexterm downloads nothing and calls nothing on first run.

Set up Kev on your own machine#

1. dexterm classifier doctor               your RAM, CPU and GPU, and the model tier it recommends
2. dexterm classifier pull kev-4b-q4       shows the size and the source, asks, checks the disk, verifies the sha256
3. dexterm classifier pick kev-local kev-4b-q4
4. dexterm classifier serve                runs llama-server on 127.0.0.1 (leave it open)
5. dexterm classifier try                  one labelled estimate, to see it work

You need llama.cpp's llama-server from a build released on 2026-10-02 or later: that is when it gained the /v1/systemone endpoint decision models use. Put it on your PATH, or point DEXTERM_LLAMA_SERVER at it. Downloads come from the pinned revision of the model's Hugging Face repo and are checked against a sha256 before use. Once a model is downloaded, it works fully offline.

If the picked model is not running, the built-in scores answer instead, and the answer says it is a fallback.

Which model for which machine#

dexterm classifier doctor reads your RAM, CPU and GPU and suggests one of these:

kev-0.8b-q8 is in the list but not suggested: on dexterm's own history it ranked coins no better than chance. Serving uses about 2.5 GB of RAM for the 0.8B model and about 5.5 GB for the 4B model; the 9B model used about 6.6 GB of GPU memory.

Hosted Jev with your own key#

dexterm classifier key set          paste your TypeSafe API key (hidden input; stored 0600 under ~/.dexterm/keys)
dexterm classifier pick jev-hosted

dexterm never ships or shares a key. The key is sent only to https://api.typesafe.ai, never printed, and never stored in classifier.json. TYPESAFE_API_KEY in the environment works too. Each call counts tokens. Set your price per million input tokens in ~/.dexterm/classifier.json (jev.pricePerMTokUsd) to see a cost in dollars; until you do, the cost shows as unpriced, never as $0. A daily call cap (jev.maxCallsPerDay, default 1,000) stops calls before they reach the network. A rate limit from the API is reported with its retry time.

How they measured on dexterm's own history#

dexterm's benchmark (October 2026) asked each model about coins whose outcome we already know: 1,054 coins from the LARP eval set (rugged or dead within 72 hours?) and 1,800 coins from the recorder's history (drained within 6 hours?). The rules and the pick were fixed before the final held-out coins were scored, and those were scored once. AUROC says how well a model ranks the coins that went bad above the ones that did not: 0.5 is a coin flip, 1.0 is perfect.

What this means:

• No model is good at this yet. Predicting a coin's next six hours from what is known now is hard for everything we tried, including the built-in scores. Treat every estimate as one weak input, never as a verdict.
• Kev 0.8B ranks coins no better than chance and gives almost the same number for every coin, so dexterm never suggests it.
• Kev 4B is the model dexterm classifier pull suggests if you want a local model: it was the best Kev on the development coins. On the held-out coins it tied the built-in scores (no better, no worse), so the built-in scores stay the default.
• Claude (zero-shot) ranked best on both questions, but it needs your Claude login, the network and a small cost per coin, so it is a comparison point, not a default.
• Kev 9B (measured later, on a GPU) is fast, a fraction of a second per coin, but no better. On the development coins it trailed Kev 4B on the drain question. On the held-out coins it tied both the built-in scores and Kev 4B: its 0.79 on the LARP question and 0.53 on drain are within chance variation of theirs. So kev-4b-q4 stays the suggestion, and the 9B model is there if you want to try it.
• Kev 27B and the open JEV models were not measured (no file llama.cpp can run, or a GPU larger than 16 GB needed). They may do better; we do not know.
• Hosted Jev was not measured: it needs a TypeSafe key, and dexterm's own tests run against a stand-in server only.
• Kev was trained on general text decisions (intents, reviews, policies), not on memecoins. Its authors' accuracy figures are about those tasks, not this one.

dexterm classifier bench times the model you picked on your own machine (seconds per coin and per 1,000 coins).

Where it plugs in#

• Agents (MCP): classify_coin (one coin), classify_batch (up to 100 coins, with triage: flag, pass, or escalate the uncertain ones to Claude or to you) and classifier_status.
• Watch rules: the rugp field is the drain estimate of a coin the classifier has scored, for example when rugp > 0.8 then alert(warn, "classifier: high drain estimate") scope watchlist. A coin that has not been scored never matches.
• Research: the benchmark writes each coin's probabilities as columns, so entry-gate research can test them as one more input.

Settings#

~/.dexterm/classifier.json (0600). Only dexterm classifier writes it.