Models & tokens.

THE ROOT CHOICE

Which model writes the show.

Every word the DJ speaks and every track it picks comes from one language model, chosen under Admin → LLM. The default is Ollama on your own hardware (no API key, no per-token bill), but you can point the station at a hosted provider (Anthropic, OpenAI, Google, OpenRouter and others) instead. Switching reroutes every call immediately, with no redeploy.

“On your own hardware” isn’t only Ollama — there are three local paths, all keyless and all private to your box:

• Ollama— the default. One install, pull a model, done. Ollama’s cloud models (the :cloud tags) also ride this path: same setup, the heavy lifting happens on their hardware.
• locca — a first-class, one-command local model server (locca serve <model>) built on llama.cpp. No key, a sensible host default, and the onboarding wizard can detect it for you. locca on GitHub ↗
• OpenAI-compatible — any self-hosted server that speaks the OpenAI API (llama.cpp, vLLM, LM Studio); you supply its URL.

One thing to internalise before choosing: the provider is part of the choice. The same model can behave differently through different routes, because each provider translates tools and structured output its own way — a model that fails through one route can be flawless through another. When you evaluate a model, evaluate it through the provider you’ll actually run.

MEASURED, NOT GUESSED

Which models hold up.

SUB/WAVE ships a benchmark that drives every kind of call the DJ makes — track picks, talk segments, listener requests, scripts, banter, programme plans — against any model, in both picker modes, and scores the output against the station’s own rules. The table below is the running record — it grows as more models and providers get benched (station configured lean unless noted):

Reading it for a recommendation: pick an agent-capable row if you want the full conversational picker — Gemini 3.5 Flash leads the table outright, its Flash-Lite sibling matches the 31B class at the fastest picks benched, and Gemma 4 31B on Ollama cloud remains the best keyless option. Pick any healthy pool-mode row for a lean station (Qwen3.5 9B is the small floor, and a local Gemma 4 12B — locca serve gemma4 — does the same job keylessly on your own box). Remember the route in the second line of each model cell is part of the result — the same model through a different provider can score differently, and two of the scores above changed by 20+ points once bugs in our own thinking-suppression plumbing were found and fixed. The bench checks that too, now.

Two patterns worth knowing whatever you run: the Gemma family at every size shares the same habits (it can repeat an artist when the shortlist pressures it to, and it fumbles feature choices on three-hour programme plans), and the multi-hour programme plan is the hardest single call in the system — the only one that dented every model tested. If a show misbehaves, suspect the plan before the model.

Running from a clone? You can put any candidate model through the same battery before trusting it on air: npm run llm-bench in controller/benchmarks it across every call kind and prints a comparison table. The DJ Doctor’s LLM checks cover the everyday health of whatever you’ve picked.

RUNNING LEAN

For small models & saving tokens.

If you’re on a modest local model, or paying per token and want the bill low, these are the dials to turn down. None of them take the DJ off the air. They just make it do less work per moment.

• Picker agent off(Admin → LLM) — the big one. With it off, the station runs everything in one-call-per-moment style: track picks come from a short pre-built shortlist, and the talk segments (weather, news, curiosities) fetch their data first and make a single call too, instead of running a tool-using agent. Far fewer tokens, and a task shape small models get right — this is the setting that makes the 9B–12B class reliable.
• Reasoning off(Admin → LLM) — stops “thinking” models from writing a long internal monologue before they answer. The DJ writes short scripts that don’t need it, and an unbounded thinking step can balloon a call from one second to minutes — or eat the whole reply. Off is the safe default; the station knows how to genuinely switch thinking off per provider, including the model families that ignore the polite version of the request.
• Pause when empty on(Admin → LLM) — when nobody is listening, the DJ stops picking, talking and writing IDs entirely; the stream coasts on the fallback playlist and the DJ wakes up the moment someone tunes in. This one is a pure saving: there’s no quality cost, since there’s no one there to hear it.
• Concise scripts(Admin → Personas) — each persona’s script length runs from one-liner through concise and extended to storyteller. Concise keeps spoken breaks to a line or two; the longer stops double or triple them.
• Quiet frequency(Admin → Personas) — a persona’s frequency sets how often it talks, IDs the station and reads the time and weather. Quiet makes all of that rarer, so there are simply fewer AI calls per hour.
• Sound FX off(Admin → Imaging → SFX) — with the effects library disabled, the DJ is no longer shown the catalogue of stingers when it plans a segment, which trims that prompt.

With the lean profile in place, Qwen3.5 9B or a local Gemma 4 12B runs the whole station comfortably — picks, requests, talk breaks, even programme shows — while paying nothing per token.

RUNNING RICH

For large, capable models.

On a capable model the same dials go the other way: spend the capability on a station with more personality and a smarter DJ.

• Picker agent on(Admin → LLM) — the full conversational DJ: it remembers the session, reasons about what it has already played, and uses tools to dig through the library. Richer and more coherent — but it’s a genuinely harder job, and the bench is blunt about who can do it: Gemma 4 31B (Ollama cloud), MiniMax M2.7and hosted models of GPT-5-Mini’s class run it reliably; the 9B–12B locals do not. You don’t need to guess — turn it on and watch the booth log; every agent miss falls back to the pool picker anyway.
• Reasoning on(Admin → LLM) — let a thinking model work through its choice before answering. Worth trying only on a model built for it and a generous token budget; the picker and other structured calls suppress thinking regardless, so this mainly buys more considered scripts.
• Extended scripts(Admin → Personas) — a storytelling DJ that lingers, with longer links between tracks.
• Aggressive frequency(Admin → Personas) — a busy station: frequent IDs, time checks and weather updates.

A SECOND, SMALLER MODEL

How the DJ knows each track’s mood.

The DJ picks partly by mood— mellow mornings, brighter afternoons, a wind-down late at night. To know each track’s mood it leans on the library tagger, which uses a second, much smaller embedding model — not the chat model that writes the show.

Rather than ask the chat model about every track (slow and expensive on a big library), the tagger embeds each track once, has the chat model tag a small, representative seed set, then propagatesmoods and energy out to everything else by similarity. That’s roughly ten times fewer model calls than tagging track by track.

By default the embedding model follows your LLM provider, so there’s usually nothing extra to set up — an Ollama-local station gets nomic-embed-text for free. Two things are worth knowing if you stray from that:

• Anthropic has no embedding model — if your DJ runs on Claude, point embeddings at Ollama or OpenAI instead.
• Some providers do chat only — the deepseek and Vercel AI gateway providershave no embeddings endpoint at all. A DJ on one of those works fine, but the tagger can’t follow it, so the console only lists embedding-capableproviders in the tagger dropdown (Ollama, OpenAI, Google, OpenRouter, locca, OpenAI-compatible). If you don’t see your chat provider there, that’s why — pick Ollama (local and free) for the embedding step and leave the DJ where it is.
• Provider vs. model — mind the difference on a router.“DeepSeek” is a provider (no embeddings), but it’s also a model you can run through OpenRouter. Those aren’t the same: pick the OpenRouter provider with a DeepSeek chat model and your DJ speaks via DeepSeek while embeddings go through OpenRouter’s own embeddings endpoint — by default openai/text-embedding-3-small. OpenRouter, Requesty and the like carry everything (chat and embeddings); the bare provider named after a chat-only company does not.
• locca and OpenAI-compatible need a dedicated embedding server— one llama.cpp process can’t serve chat and embeddings at once. With locca that’s a second command, locca embed, on its own port; the console can detect it for you.
• Which one should I pick? Any embedding model at 768 dimensions or moreis fine for mood similarity — favour a fast, cheap one over a big “best-in-class” model. Good baselines: nomic-embed-text (local, free, 768-d) if you run Ollama, or text-embedding-3-small (cloud, cheap, 1536-d) otherwise. The exact model matters far less than picking one and sticking with it — see the next note.

One catch worth internalising:the vector index is built at your embedding model’s dimension, so changing the embedding model means re-embedding the whole library(Admin → Library tagger → Re-scan → “Re-embed all tracks”). Changing the chatmodel never needs this — but if embeddings are set to “follow the LLM,” switching your DJ providerquietly changes the embedding model too. The console pins embeddings to your library’s model and warns you before that happens, so the safe move is to pin an embedding provider once and leave it.

It all lives under Admin → Library tagger, and you can see the tagged library laid out in Library Observatory.

WHERE TO SET THEM

All of this lives in the console.

Every setting here is in the admin console and takes effect without a redeploy; most apply to the next thing the DJ does. The full tour of the console is in Admin & Settings; how the DJ actually picks and talks is in How the DJ Works.