Day 84 — the composer is where the mind lives

“we can hack that mainframe with my super logic now.”

Yesterday ended on a hard truth: the weights can only speak. A 5M byte-level model will never learn to read the valence in “I lost my job” — that’s comprehension, and comprehension doesn’t fit. The architecture’s answer was to move the knowing out of the weights and into the composer.

Today we did that twice — for feeling, and for thought.

The emotion lane

The bug that started it all was a model answering a laid-off user with “That’s awesome!” B.18 proved retraining wouldn’t fix it. So we built the fix where it belonged: a lane that reads the emotion in a message and composes the right response, deterministically, never from the babbling weights.

It grew fast. Distress that sits with grief instead of cheering at it, and self-harm language that routes to a real referral — 988, not a comfort line. Anger that owns the mistake when it’s aimed at werbos (“you’re right, that’s on me — tell me what you needed”) and validates it when it’s aimed elsewhere. Then the operator asked for the fun one — hype — and it landed the hardest distinction of the day: “FUCK YES” is hype and “FUCK YOU” is anger, the same two words read by what follows them. By the end the range covered nine states — grief, health, rejection, setback, fear, guilt, confusion, gratitude, pride, relief, hype, anger, crisis — each with a stance a verifier guarantees: it cannot cheer at grief, cannot get defensive at anger, cannot wet-blanket a celebration. Real emotional range on a model that reads none of it in its weights.

Reasoning is execution, not narration

Then the shape of the day turned from feeling to thought, and the operator named the thing exactly: multi-step planning is the substrate under reasoning. input → step → step → output — an answer you arrive at without having stored it.

So we built it up. A flat “build a function, run it” that showed each stage and printed the real sandbox output became a recursive tree: nested plans, leaves that execute for real, state that carries from one to the next, and — the part that makes it trustworthy — honest partial completion. Chain a step werbos can’t execute ("…then hack the mainframe, then profit") and it stays ✗ while everything runnable stays ✓. Status propagates up: a branch is done only if every leaf is. The ? step never gets a checkmark.

Then the leaves became tools — calc, code, lookup, fetch — the operator’s own three primitives made literal: execute, retrieve, abstain. Adding a skill is one decorator. And on top, a planner that takes a whole question, decomposes it, routes each part to the right tool, and runs the plan: “what’s 15% of 240, and what is a closure in JavaScript?” becomes a calc and a lookup, each executed and cited, wired into the brain so it reasons on its own — while carefully never hijacking a plain lookup or fracturing a comparison the way a naive splitter would.

The difference from every large model’s chain-of-thought is the whole point. CoT narrates plausible steps and is confidently wrong all the time, because no step was ever checked. werbos runs the steps and abstains where it can’t. It’ll match your energy on the parts it did, and it will not fake the part it didn’t.

The lesson

Two arcs, one conclusion, and it’s the same one as yesterday from the other side. Yesterday: the weights can only speak. Today: the composer is where the mind lives — where a message gets understood, where an answer gets derived, where the honest gap gets marked instead of papered over. The 2M didn’t get bigger. It got a mind around it.

Sixteen days to the gauntlet. The minters never stopped — cards on one box, conversation pairs on another, tomorrow’s model building itself in the background while today’s got a composer worth the name.