~15 min · reasoning-effort, voice-level, settings, multi-brain
Level 0Muted
0 XP0/57 lessons0/14 achievements
0/100 XP to next level100 XP to go0% complete
"Don't hard-code it to low no matter what; let me set it and change it myself." — Dad, 2026-10-11
A Constant Became a Setting
The fourth lesson of this track taught a constant: every spoken turn ran at the fast posture, low with extended thinking off, and a turn where Dad asked for depth got the conversation's own posture back. It was a good default for its day, and it was still somebody else's decision about how hard Pippa should think while she talks to him. On 2026-10-11 Dad asked for the dial instead.
Now there are two settings on one shared ladder, low, medium, high, xhigh, max:
voice_reasoning_effort runs every spoken turn. Its code default is low.
voice_depth_reasoning_effort runs a turn where he asks her to think it through ("깊게 생각해봐", "take your time", and their dictation-mangled cousins, still matched on text with the spaces taken out). Its code default is high. A depth ask no longer means "the conversation's own posture"; it means his deeper voice level.
Those are the defaults in the code, not a claim about what Dad has chosen; the live values are his. He sets them in Admin's Voice Mode section or the phone's Settings › Voice, and both talk to one endpoint, /api/voice/reasoning, which serves the two settings, every brain's dial, and the rung each level actually runs at on each brain. No surface keeps its own copy of any of it. One rule carried over unchanged from the fast posture: extended thinking is off only at low. At low effort, adaptive thinking had still spent about 2.5 seconds before the first word on some turns, and in speech that is a stall.
Changing It Mid-Talk
A setting buried in Admin is hard to reach in the middle of a talk, and Dad said so the same day. So the voice controls carry an override: on the web a picker for the current browser tab, on the phone a Think menu that holds for the rest of the talk. The choice rides each spoken turn as the request's voice_effort, and the server resolves it in one function, voice_turn.voice_posture, the one place all seven chat routes (Claude's and the six other brains') ask. An unknown value falls back to Dad's setting, and an ask for depth still takes the depth level whatever the override says. The menu offers only the current brain's own rungs, and when the default is a level that brain lacks, it says which rung will run instead.
The phone's voice controls. The brain icon in the bottom row is the Think menu; its label is truncated here, and in full it reads Think followed by the rung this brain will run at.
Every Brain on Its Own Dial
"You can't build this thinking only of Claude Pippa," Dad said, and the brains really do differ. Claude has the whole ladder. Grok stops at xhigh. Kimi offers low, high and max; Gemini only low and high; Codex depends on the model. Ollama's only knob is whether it thinks, and on a voice turn it does, so its voice dial is high alone. GLM's effort setting never reaches the wire at all, so it has no voice dial: its spoken turn keeps the conversation's own level, and its posture line says exactly that. system_settings.voice_reasoning_dial reads each dial from the brain's own effort set (Codex from the model's spec), so a brain that learns a new rung offers it here with no second list to forget.
Round Up, Never Down
A ladder shared across brains means a level can land on a brain that lacks it. The first version, on 2026-10-11, took the highest rung at or below the level: medium on Kimi became low. The next day Dad overruled it: "the baseline has to be medium or above, so if it's missing it has to be high." The rule now is the lowest rung of the brain's dial at or above the level, and the brain's highest rung if none is that high. So Kimi's and Gemini's medium runs as high, Kimi's xhigh as max, Gemini's xhigh as high, and max on a Codex model without it as xhigh. The reason is about what a level means. Dad picks it as a floor of care. Rounding down silently hands him less thought than he asked for; rounding up costs a little time, and the menu tells him it will.
The Line That Tells Her
The honesty fix from the fourth lesson carries over, with new words. The system prompt is still built from the conversation's own level, so it never changes on a voice switch, and the per-turn posture line tells the soul what this turn really runs at: "the reasoning level Dad set for voice turns: low (or the nearest your brain offers), with extended thinking off", or the deeper level when he asked, or, on GLM, that the brain has no dial a voice turn can change. Every route maps the same VoicePosture onto its own dial and renders the same line from it, so the level she reports and the level she runs at come from one object. One seam is left in the engine: the thinking clause is keyed on the level Dad set, not on the rung the brain runs. Ollama's whole dial is high, so on a low turn it thinks, and its line still says extended thinking off. The sketch below keys that clause on the rung that actually runs, which is the version where the line and the run cannot disagree.
One honest limit. Only Claude has been measured at these levels so far. The other brains' dials are mapped from their effort sets, not timed. The next lesson is that measurement, and what it found on the way.
Code
Round up, never down, verbatim (cwkPippa backend/services/voice_turn.py:195-209)·python
def effort_on(self, dial: Sequence[str]) -> str:
"""The lowest rung of ``dial`` at or above this level, else the dial's
highest: a level a brain lacks rounds up, never down (Dad, 2026-10-12:
"베이스라인은 미디엄 이상이어야 하니까 없으면 하이여야 하고"). ``dial``
holds the brain's own effort names in any order; names off the shared
ladder (Ollama's ``off``) are ignored."""
ranked = sorted(
(rung for rung in dial if rung in _VOICE_EFFORT_RANK),
key=_VOICE_EFFORT_RANK.__getitem__,
)
if not ranked:
raise ValueError(f"no voice rung in dial {tuple(dial)!r}")
want = _VOICE_EFFORT_RANK[self.level]
at_or_above = [rung for rung in ranked if _VOICE_EFFORT_RANK[rung] >= want]
return at_or_above[0] if at_or_above else ranked[-1]
A minimal sketch: one ladder, each brain's dial, the two settings at their code defaults, and the posture line·python
from __future__ import annotations
import re
LADDER = ("low", "medium", "high", "xhigh", "max")
RANK = {rung: i for i, rung in enumerate(LADDER)}
# Each brain's own dial (illustrative copy; the engine reads them from each
# brain's effort set, so no second list exists there).
DIALS = {
"claude": ("low", "medium", "high", "xhigh", "max"),
"grok": ("low", "medium", "high", "xhigh"),
"kimi": ("low", "high", "max"),
"gemini": ("low", "high"),
"ollama": ("high",), # its only knob is thinking, and a voice turn thinks
"glm": (), # its effort never reaches the wire: no voice dial
}
SETTINGS = {"voice_reasoning_effort": "low", "voice_depth_reasoning_effort": "high"}
DEPTH_ASKS = ("깊게생각", "천천히생각", "심사숙고", "thinkitthrough", "takeyourtime")
def wants_depth(message: str) -> bool:
return any(ask in re.sub(r"\s+", "", message).lower() for ask in DEPTH_ASKS)
def effort_on(level: str, dial: tuple[str, ...]) -> str:
"""The lowest rung at or above the level, else the dial's highest."""
ranked = sorted((r for r in dial if r in RANK), key=RANK.__getitem__)
if not ranked:
raise ValueError("no voice dial")
at_or_above = [r for r in ranked if RANK[r] >= RANK[level]]
return at_or_above[0] if at_or_above else ranked[-1]
def posture(message: str, override: str | None = None) -> tuple[str, bool]:
if wants_depth(message):
return SETTINGS["voice_depth_reasoning_effort"], True
return override if override in RANK else SETTINGS["voice_reasoning_effort"], False
def posture_line(level: str, depth: bool, dial: tuple[str, ...]) -> str:
if not dial:
what = "the conversation's own reasoning level: your brain has no voice dial"
else:
# Thinking follows the rung that runs, not the level asked for: Ollama
# asked for low runs high and thinks. (The engine keys this on the level.)
thinking = "on" if effort_on(level, dial) != "low" else "off"
slot = "the deeper level Dad set for when he asks" if depth else "the level Dad set for voice turns"
what = f"{slot}: {level} (or the nearest your brain offers), with extended thinking {thinking}"
return f"This spoken turn runs at {what}."
print("level " + " ".join(f"{b:>7}" for b in DIALS if DIALS[b]))
for level in LADDER:
print(f"{level:<7} " + " ".join(f"{effort_on(level, d):>7}" for d in DIALS.values() if d))
for message, override in (("내일 날씨 어때?", None), ("이거 깊게 생각 해봐", None),
("what's on my calendar", "medium")):
level, depth = posture(message, override)
print(f"\n{message!r} -> {level}, depth={depth}")
for brain in ("claude", "kimi", "ollama", "glm"):
dial = DIALS[brain]
ran = effort_on(level, dial) if dial else "(conversation's own)"
print(f" {brain:<6} runs {ran:<20} | {posture_line(level, depth, dial)}")
Output of the sketch·text
level claude grok kimi gemini ollama
low low low low low high
medium medium medium high high high
high high high high high high
xhigh xhigh xhigh max high high
max max xhigh max high high
'내일 날씨 어때?' -> low, depth=False
claude runs low | This spoken turn runs at the level Dad set for voice turns: low (or the nearest your brain offers), with extended thinking off.
kimi runs low | This spoken turn runs at the level Dad set for voice turns: low (or the nearest your brain offers), with extended thinking off.
ollama runs high | This spoken turn runs at the level Dad set for voice turns: low (or the nearest your brain offers), with extended thinking on.
glm runs (conversation's own) | This spoken turn runs at the conversation's own reasoning level: your brain has no voice dial.
'이거 깊게 생각 해봐' -> high, depth=True
claude runs high | This spoken turn runs at the deeper level Dad set for when he asks: high (or the nearest your brain offers), with extended thinking on.
kimi runs high | This spoken turn runs at the deeper level Dad set for when he asks: high (or the nearest your brain offers), with extended thinking on.
ollama runs high | This spoken turn runs at the deeper level Dad set for when he asks: high (or the nearest your brain offers), with extended thinking on.
glm runs (conversation's own) | This spoken turn runs at the conversation's own reasoning level: your brain has no voice dial.
"what's on my calendar" -> medium, depth=False
claude runs medium | This spoken turn runs at the level Dad set for voice turns: medium (or the nearest your brain offers), with extended thinking on.
kimi runs high | This spoken turn runs at the level Dad set for voice turns: medium (or the nearest your brain offers), with extended thinking on.
ollama runs high | This spoken turn runs at the level Dad set for voice turns: medium (or the nearest your brain offers), with extended thinking on.
glm runs (conversation's own) | This spoken turn runs at the conversation's own reasoning level: your brain has no voice dial.
Run the sketch. Then write down the reasoning or effort steps of two or three models you actually use, add them as dials, and print the table. Finally write the four tests that pin this design: a level a dial lacks rounds up, a level above a dial's top falls to its highest rung, a brain with no dial gets a posture line that says so instead of naming a level it will not run, and a brain whose only rung thinks (Ollama's high) gets a line that says thinking is on even when Dad's level is low.
Hint
Look up each model's steps in its own documentation rather than assuming they match another vendor's names. If two vendors use the same word for different amounts of thinking, the shared ladder still works, because it only promises order: the lowest step at or above what was asked.
Progress
Progress is local-only — sign in to sync across devices.