你的 Agent 正在付费让聊天模型说“是”

Watch an agent work a real task and count the decisions nobody sees. Which skill fits this request. Which part of a 4,000-line command output actually matters. Is the gap the verifier flagged real, or noise? Each one ends in a one-word answer. And until this week, every one of them went to a full chat model that had to reason its way there, token by token — like a staff engineer asked to pick the lunch spot. In Octomind 0.54.0 we stopped doing that. Those decisions now go to Jev, a model that cannot write a single token of text. On our cloud, each answer came back in 0.5 to 1.3 seconds and cost between $0.00001 and $0.0001. This is the story of why we bet our agent's control plane on a model with no voice. The model that can't write Jev is from TypeSafe AI, named after the Jevons paradox, and it went viral on X in mid-September for a reason I respect: it does one thing. You hand it a state and a typed question — yes/no (Noul), pick one of N (Choice), score this against a rubric (Score) — and it returns a calibrated probability. That's the whole interface. No generation, no prose. The numbers that got my attention: 70–500 ms per answer, $0.042 per million input tokens, and output is free because there is nothing to bill. Malte Ubl (@cramforce) ran it on a classifier eval he'd previously served with Gemini 2.5 Flash Lite — it saturated the eval on quality at 6x the speed. One developer ran roughly 5,000 requests for $2. Two pieces of fine print, because I'd want them if the positions were reversed. TypeSafe's homepage flashes 193.6x and 444.6x multipliers, but their own blog hedges those as the high end of real-world gains — treat them as marketing, not measurements. And the "0% tool-call errors" claim is true by construction: with a closed, typed answer space, Jev can pick a wrong option, but it cannot invent a malformed one. Honestly? That's exactly the property I want in a control plane. Wrong is recoverable. Malformed is a pager at 3 a.m. Five seams Inside Octomind, Jev now sits at five seams — the places where the runtime used to pay a chat model for a judgment call: Skill routing. When no rule matched a request, Jev picks the right skill instead of a chat model deliberating over a menu. Output scoring. Long command output gets scored chunk by chunk, so the agent reads what matters and skips the rest. Double-checking the checker. When the verifier flags a gap, Jev confirms it's real before the agent tears down and redoes fine work. Memory hygiene. Only relevant, grounded lessons get written to memory. Less sludge in, less sludge retrieved later. Planning. When planning would add nothing, Jev says so, and the agent skips it. A typed question looks roughly like this (illustrative, not the real API): { "type": "noul", "question": "Is this verifier-flagged gap a real defect?", "state": { "diff": "...", "test_output": "...", "gap": "..." } } // → { "answer": true, "probability": 0.91 } Enter fullscreen mode Exit fullscreen mode One question in, one probability out. Compare that to what we replaced: a chat prompt, a few hundred tokens of reasoning, and a parse step praying the model didn't wrap "yes" in a paragraph. The trust boundary Here's the design decision that made it safe to ship this on by default: on the checks it stands in for, Jev can only hold work back. It can never mark work done. Follow the failure modes. Jev says a flagged gap is real when it isn't? The agent redoes a check — wasted seconds, no harm. Jev says a gap isn't real when it is? It still can't wave work through, because approval was never its job; the verifier owns that. Jev slow, down, or unreachable? The agent does exactly what it did before 0.54 — the old chat-model path is the fallback, not an error state. Every failure direction is cheap. That asymmetry is the whole reason we were comfortable flipping this on for everyone, Free plan included, without a settings toggle to hide behind. If you take one thing from this post: give your cheap, fast model veto power, never approval power. What it costs, what you see Jev routing is on by default on every plan, including Free, billed at $0.042 per million input tokens. In a session, type /info and Octomind tells you how many chat-model calls Jev replaced — your own run's receipt, not our benchmark. Ours, from the cloud: answers in 0.5–1.3 seconds, $0.00001–$0.0001 each. The chat model still does everything that needs a chat model — writing code, explaining, reasoning through genuinely open problems. It just stopped being a very expensive yes/no machine. What I'd tell other agent builders Count your one-word answers. Grep your agent's call sites for prompts that end in a classification. We found five seams; you'll find your own, and they'll be embarrassing. Ours were. Prefer typed over generated wherever the answer space is closed. If the output is a choice, a boolean, or a score, generation is overhead — latency, tokens, and a parse failure mode you don't need. Design the failure direction before you design the feature. The trust boundary took an afternoon. It's the only reason this shipped on by default instead of behind a flag nobody finds. Expect Jevons. The model is named for the paradox, and the paradox is real: when decisions get 100x cheaper, you don't make the same decisions faster — you start making decisions you used to skip entirely. We're already scoring things we'd never have bothered scoring when every check cost a chat call. An agent run is thousands of small judgments. Most of them don't need a writer. They need a referee — fast, cheap, calibrated, and structurally unable to say "ship it." We shipped 0.54.0 with exactly that. Type /info sometime and see what your agent has been overpaying for.