Voxta Thinking models
How much a model reasons before it answers, and how to tell whether it actually did.
Some models reason before answering. There are two ways that reaches Voxta, and only one of them needs anything from you:
- In its own response field — OpenAI, OpenRouter, Voxta Cloud, KoboldCpp. The service takes an API parameter and Voxta passes it along. Set Reasoning Effort on that service and you are done.
- In the output tokens — a
<think>…</think>block in the middle of the reply, which Voxta has to split out. Every local model works this way, and this page is about those.
The settings
All under Thinking Models in the prompting preset.
| Setting | What it does |
|---|---|
| Thinking Model | The master switch. Also suppresses reply prefixing, which would otherwise land inside the thought instead of the reply. |
| Reasoning Effort | How hard to think. See below. |
| Max Thinking Tokens | The budget. Default 2000. |
| Thinking Budget Message | What to put in the model's mouth when it hits the budget, just before the block is closed for it. |
Max Thinking Tokens is enforced, not just a cap on generation. At the budget the thought block is closed — optionally with your transition message — rather than truncated. That is the whole point: a trace cut off mid-sentence with no end tag leaves a reply Voxta cannot separate from the thinking.
Reasoning effort
There is no API parameter for this on a local model. The level is a sentence the model was trained to read, in wording its makers chose, so it ships with the prompt formatting template rather than being invented here.
| Level | Meaning |
|---|---|
| Default | Say nothing about effort; let the model do what it does. |
| None | Don't think at all. |
| Low / Medium / High / X-High | The template's wording for that level. |
A level the template doesn't declare is one the model never learned, so asking for it leaves the prompt alone rather than inventing wording. Qwen 3.8, for instance, knows Low and X-High, and defines its Medium as the absence of an instruction — which is what Default already sends.
None is more than a wording. It also stops Voxta opening the model's turn with a thought tag, which is what silences a model that only thinks when prompted to. The block is still parsed out either way, because Gemma 4 and Qwen 3.8 emit an empty one regardless and it must not reach the reply.
Per service type
Reasoning effort can be overridden separately for Assistant, Action Inference and Summarization, in each of those services' own settings rather than under Thinking Models.
This matters more than it sounds. An assistant answer has no voice latency to respect. Action inference picks one item from a short list — and pays for reasoning every turn.
If replies feel sluggish with a thinking model, set Action Inference → Reasoning Effort to None first. That is usually the one costing you.
Checking it actually reasons
Both halves of this fail quietly:
- A model that stopped reasoning still answers perfectly well. It just doesn't think.
- A trace whose tags nothing recognizes is read out as the character's reply, chain of thought and all.
So Test services probes it on every LLM module at once: it asks a question worth thinking about, then checks that thinking tokens arrived and that neither tag leaked into the answer. It runs only when your preset asked for reasoning, and names the likely cause when it fails — usually a template with no thought format, or one that doesn't open the model's turn.
If a model reasons in the CLI and not in Voxta, suspect the template it resolved to. A GGUF carrying no chat template of its own can match a generic template that declares nothing about thinking, and the symptom is a model that answers everything and thinks about none of it.
Things that turn it off on purpose
Two requests never open a thought turn:
- Anything using a response schema. The grammar constrains the first token, so a turn opened with a thought tag asks the model to continue from text the schema forbids. Structured output and reasoning-in-tokens are mutually exclusive.
- Anything whose stop sequences the closing tag would trip. Summarization stops on
</, and every thought ends with</think>.
Stop sequences while thinking
A stop sequence says where the reply ends. Inside the thought it's just a word the model is reasoning with — and a roleplay chain of thought reasons about dialogue, so \nJohn: shows up in it constantly. Matching there would end the generation with nothing but a thought, which reaches you as an empty message.
On llama.cpp, ExLlamaV3 and LlamaSharp, Voxta does its own stop matching and holds off while the model is still reasoning. On backends where the matching happens inside a server Voxta only talks to — KoboldCpp and ExLlamaV2 — it cannot, and Disable Stop Words remains the only way out.