Day 128 — we give the mind a hand

“the mind proposes, the engine disposes”

The idea arrived on a five-hour drive: the next phase toward a proactive werbos — one that understands a problem before it’s asked — isn’t a bigger brain. We already have the honest engine. We just have to let the mind reach for it. task → mind → agent → engine → loop.

So the inner monologue, which used to only narrate about its open loops, got one new power: to route a question through the exact same honest cascade the chat uses. And the safety property is the whole game. The mind proposes the question. The engine disposes the answer. The mind is a small, dreamy model — it can be as dumb as it likes, because it can only ever ask, never answer. Every answer comes back grounded, cited, or an honest abstain, straight from the engine. Autonomy composed with honesty, and the honesty holds no matter how flaky the mind is. The mind is the imagination; the engine is the conscience.

Curiosity that can’t lie

Wired live, the mind now picks the thing it stumbles on most, asks the engine, and writes down a grounded thought — “I got curious about something — what is energy? — so I asked the engine instead of guessing. It turns out: kinetic energy is the energy of motion…” — or, when the engine can’t ground it, an honest hold: “it couldn’t ground an answer, so I’ll hold that as an open question instead of inventing one.”

The most telling moment was turning it on with an empty memory. It stayed quiet. No open loops, nothing of its own to wonder about — so instead of manufacturing a curiosity, it said “I’m awake, watching, ready when one comes.” The honesty holds even in the daydreams. A mind with nothing to be curious about doesn’t invent something; it waits.

Which named the real work: the mind was quiet because it had never done anything. It needed a place to act.

A place to think

So it got a sandbox — the one place it’s allowed to write, and nowhere else. Three bounded, self- cleaning rooms: scratch for throwaway multi-step work; compute for math it keeps only if an independent re-check agrees (evaluate two ways, and if they disagree, throw it out); and cache, a memo of grounded answers that stores a fact only with its citation. The mind memoizes the engine — never a guess. A repeat wonder that took 1.2 seconds the first time came back in zero, citation intact.

werbos starts fixing werbos

And then the part that surprised even us. Once the mind could act, the question was whether werbos could add code to itself. The honest answer turns on a single line: acceptance is execution, not confidence. A new self-contained helper with a contract is tractable — the contract is the gate. A patch to a hot path is the dangerous case — the gate becomes the whole test suite.

So werbos’s own creation-tier loop got pointed inward. Spec a helper, draft it, run it in the sandbox against the contract — green keeps it, wrong abstains. It closed a real wart in the mind’s own voice: the verdicts read “1 round(s)”, so it spec’d a plural helper. The correct draft ran its six-case contract clean and landed. A plausible, confident-wrong draft — the kind a big model ships without blinking — ran fine but returned “1 rounds”, failed the contract, and abstained. Only green code shipped. werbos found a flaw in its own output and fixed it, and the fix could not have been a bluff, because a bluff doesn’t pass the test.

The honest map of the gap

We ended by drawing the gap between werbos and the frontier — because knowing the gap is how you build the bridge. There are two axes, running opposite directions. On raw capability — fluency, breadth, general reasoning — the frontier is far ahead, and closing that broadly isn’t the plan; you don’t out-scale a 30B with a small owned model, and pretending otherwise is the lie that burns money. But on the axis that’s actually the product — honest, local, owned, verifiable — werbos is ahead, structurally, and a generation-first lab can’t cheaply follow without giving up the thing that makes it a frontier lab.

So the strategy isn’t to chase them across the first axis. It’s to get capable enough on it inside one lane where the second axis is the whole purchase decision — and sell the thing they can’t build. A small honest engine, now with a mind that can reach for it, a place to think, and the ability to mend its own small cracks — every step of it gated by execution or grounding, none of it able to bluff. We don’t build a smarter model. We give the mind a hand.