qmax-code 1.32:
One QA Terminal,
Every Model

Two releases shipped this week, and together they finish a sentence we’ve been writing since the first version of /orch: qmax-code is the QA terminal that can switch inference.

Not “a faster Claude.” Not another IDE. The bet is simple: QA work on a repository is a sequence of very different cognitive tasks — judging a risky refactor, writing a test, triaging a crawl, healing a broken selector — and no single model is the right tool for all of them. Version 1.32 puts the whole menu in one picker.

What /orch Looks Like Now

One command, one picker, every backend. Arrow keys or number shortcuts to jump, Tab to the effort bar, Enter to switch instantly — mid-session, no restart:

qmax> /orch

✦  Claude Code
   Fable 5.1 (1M ctx · long agents)  ·  Sonnet 5  ·  Opus 4.8  ·  Sonnet 4.6  ·  Haiku 4.5
⊗  Codex
   Codex default  ·  GPT 6 Astra  ·  5.6 Sol · Terra · Luna  ·  5.5  ·  5.4  ·  5.4 Mini  ·  5.3 Codex Spark
○  Direct API
   auto (haiku→sonnet routing)  ·  Fable 5.1  ·  Sonnet  ·  Opus  ·  Haiku
◆  Cerebras  ● key set
   GPT-OSS 120B  ·  GLM 4.7  ·  Gemma 4 31B  ·  Qwen 3.8 27B (vision · agentic)

   Effort  Low   High   Medium

qmax> # pick GPT 6 Astra, keep working — the session, MCP tools, and history stay put

That is the whole interface. The interesting part is what each row is for.

GPT 6 Astra: Judgment for the Codex Harness

Astra is the model you reach for when the task is mostly thinking: a tricky test design decision, a refactor with three valid shapes, a bug that only reproduces under concurrency. Since v1.31 it runs through the native Codex harness — your Codex subscription, your Codex config for approvals and sandboxing:

$ qmax-code --backend codex --model gpt-6-astra
# or pick it in /orch — selection survives resumed threads and /clear

That last clause matters more than it sounds. QA sessions are long. You start a run, close the laptop, resume tomorrow — and the model choice has to survive that. Astra’s selection now does, across resumed turns and /clear. Choosing Codex default keeps deferring to your local Codex configuration, exactly as before.

And as of 1.32, Astra is not alone: the picker finally lists every model the runner supports — the 5.6 family (Sol, Terra, Luna), 5.5, 5.4 and its Mini variant, and 5.3 Codex Spark. Terra is the deterministic default the product picks for Auto; Mini and Spark are the cheap-and-quick rows for jobs that don’t need a frontier model. A test in the repo now fails if the picker and the runner allowlist ever drift apart, so “supported” and “selectable” stay the same list.

Fable 5.1: A Million Tokens of Patience

On the Claude side, Fable 5.1 (claude-fable-5-1) is the long-context flagship: 1M tokens, positioned for long agents — exactly the profile of a QA run that reads a whole repository, keeps a crawl map, a test inventory, and a failure history in its head at once.

• Claude Code: select Fable 5.1 in /orch and the harness runs on your Claude Code login, same as ever.
• Anthropic API: the same model is available for the built-in agent loop — no CLI needed.
• The fable alias now resolves to 5.1; Fable 5 remains selectable for continuity.

The practical difference shows up in whole-repo reasoning. “Which flows have no coverage at all?” is a question that benefits from seeing everything at once instead of paging through the tree. That’s Fable’s job. The one-line review of a two-line diff is not. That’s what the fast tier is for.

What Cerebras Actually Is (and Why It’s in a QA Tool)

Cerebras is an inference provider that builds wafer-scale chips — entire silicon wafers as single giant processors — and runs open and open-weight models on them at speeds conventional GPU clusters don’t match. In qmax-code sessions we regularly see ~1,000–2,000+ tokens per second. For comparison: that’s an order of magnitude over typical API latency.

Speed alone is a gimmick. Speed plus an OpenAI-compatible API with native function calling is a workflow change: the full qmax toolset — all 50 tools, crawls, test generation, execution, healing — runs on Cerebras natively. The models hosted there today:

A key from cloud.cerebras.ai, pasted once when you first switch, and the picker remembers it. Costs stay low because the models are open-weight — you’re paying for silicon, not for a frontier lab’s margin.

Where Qwen 3.8 27B Fits

Cerebras serves Alibaba’s Qwen 3.8 27B as qwen-3.8-27b: a 27B dense multimodal model that takes images alongside text, does native tool calling and structured outputs, and exposes configurable thinking — at roughly 1,500 tokens per second. We staged the row in /orch ahead of launch day with the qwen config aliases already resolving, so going live cost you no migration — the switch is one keypress.

$ qmax-code config set cerebras_model qwen
# or pick “Qwen 3.8 27B” in /orch — same session, same tools, same history

One caveat worth knowing before you point it at a long queue: Qwen 3.8 27B likes to think. Left on its default it will reason its way through jobs that did not need reasoning at all, which costs you the speed you came for. It honours reasoning_effort, so the effort bar in /orch is the control that matters here — drop it to Low for triage sweeps and save the high setting for the steps that earn it.

Why we care: Qwen models are consistently strong at multilingual work, and this one can also see. A large share of real QA surface is exactly that — i18n string tables, RTL layout breakage, localized error paths, test data in three scripts at once, and screenshots where the only evidence of a bug is a translated string overflowing its button. A fast, multilingual, vision-capable model at Cerebras prices means you can point an agent at “check every locale switcher and every long-translation overflow” and let it grind through the whole matrix in the time a frontier model would have finished reading the config. Qwen 3.8 27B won’t replace judgment models; it complements them by making the high-volume, multilingual grind economically trivial. Alongside Gemma 4 31B it also gives the Cerebras tier a second pair of eyes, so screenshot-driven checks are no longer a single-model dependency.

How This Shapes Actual QA Work

Model choice became a per-task decision, not a per-tool subscription. A real afternoon on one repository:

qmax> /orch → Fable 5.1   map coverage gaps across the whole repo
✓ 41 flows inventoried · 12 with zero coverage · plan written to .qmax/

qmax> /orch → GPT-OSS 120B  generate Playwright tests for the 12 gaps
✓ 12 specs generated and executed · 9 green · 3 healed once and green

qmax> /orch → GPT 6 Astra   the 3 that kept failing — real defect or bad locator?
Astra  #2 is a genuine race in the cart logic — here’s the minimal repro
Astra  #5, #8 are nth-child locators; suggested role-based replacements

Fast models do the volume, the judgment model breaks the tie, and the effort bar (low/medium/high) tunes how hard any of them thinks before answering. You stay in one terminal, one session, one history — the switch itself costs a keypress.

And the boundary stays honest: qmax-code doesn’t try to own general coding. Cursor owns the editor; Claude Code and Codex own open-ended coding in a terminal. qmax-code owns QA on the repository — and borrows any of those brains when the job needs them.

Getting It

curl -sL https://qualitymax.io/static/install-qmax-code.txt | bash