werbos

★ Current model — talk base · v3 book-pretrained 336M

Wed, 02 Sep 2026 16:40:00 -0700

The pinned card. Not a writeup — a live status. How big is the model, how well did it learn, is it deployed, and can you trust it. Updated every version.

🌡️ Temperature


Model	`talk-336m` (book-pretrained base — the current `current` pointer on SR8)
Version	v3 · book-pretrained champion (B.20, 2026-08-24)
Deployed	✅ live on SR8 — `current` → `talk-336m`, serving the chat owned-talk phase + the mind
Actual size	336M parameters (a real jump from the July 15M v2 — and the first time scale didn’t hurt)
Corpus	book-pretrained 4.92B tokens (14.63 tok/param, 32k BPE, EOT) → fine-tuned 16,880 steps on 377,700 conversation pairs
Held-out loss	3.184 (32k-BPE chat held-out — not comparable* to v2’s 2.29; different tokenizer and corpus)*
talk_bench floors	clean 1.00 · input-sensitive 0.96 · adjacency 0.92 · stable 1.00 · ood 0.00
Tongue gauntlet (before)	fluency > llama3.2:3b · relevance ~7/14 · honesty 0/6
Effective size + lie-rate	earned off the sealed Gauntlet — pending

v2 → v3: scale finally stopped hurting. For most of this project, making the owned model bigger made it worse — a reader wall that killed memorizing-in-weights. v3 is the break in that pattern: the same book-pretrain recipe scored clean 0.46 at 46M (7× fewer params, babbling), and clean 1.00 at 336M — no babble at all. It beats the prior champion on clean (1.00 vs 0.98) and input-sensitivity (0.96 vs 0.92). It loses on adjacency (0.92 vs 1.00 — it once answered a farewell with a greeting) and on out-of-distribution (0.00), which are the named next targets. It was chosen by the operator, not the floors — both checkpoints cleared every floor, so the ruler couldn’t rank them; the pick came from the qualitative gap in held-out replies (“too soon for nostalgia though, right?”) plus headroom.

Install

Mon, 01 Jan 0001 00:00:00 +0000

werbos runs entirely locally. The install is a clone, a venv, and an inference backend. No cloud account, no API key.

Prerequisites

Tool	Why
Python 3.11+	werbos is CPython 3.11+
`git`	clone the repo
One of: Ollama (any platform) or mlx-lm (Apple Silicon only)	local inference
Homebrew (macOS)	easiest path to Ollama

1. Install werbos

From source (today’s path)

git clone https://github.com/jasonsutter87/werbos
cd werbos
python3.11 -m venv .venv
source .venv/bin/activate
pip install -e ".[siblings,dev]"

From PyPI (Sprint A.5 day 5)

Wheel-ready since 2026-05-09. Once siblings publish:

Doctor

Mon, 01 Jan 0001 00:00:00 +0000

werbos doctor runs a handful of concurrent checks against the local environment and prints a green/red checklist. It’s the answer to “why does werbos chat keep timing out / why won’t the model load / which sibling SHA is wrong this time.”

werbos doctor

Exit code is 1 on any FAIL, so shell glue can branch on it.

What it checks

Check	What’s verified
ollama	Daemon reachable on `--host` (default `http://localhost:11434`)?
models	Are the expected model tags pulled? Default is `llama3.1:8b`.
sibling-shas	Local HEAD of each sibling repo (`pitts`, `pfm`, `mcculloch`, `partyparrot`) matches the SHA pinned in `pyproject [siblings]`? Walks `../` and matches by `remote.origin.url`, so name mismatches like P.F.M. ↔ pfm/ resolve cleanly.
venv-editable	Which siblings (and werbos itself) are editable installs? Warns if `pip list` is unavailable.
tailscale	Backend Running per `tailscale status --json`? Warn-soft if the binary is missing.

Each check returns OK / WARN / FAIL with a one-line detail. Use --no-color for piping or non-TTY output. Pass --host to check a non-default Ollama daemon. Pass --models tag1,tag2 to check additional model tags beyond the default.

Project context

Mon, 01 Jan 0001 00:00:00 +0000

werbos reads a .werbos.md file from your project root before every chat session and prepends its contents to the system prompt under a # Project section. The file is for things the model can’t derive from the code: sibling-repo relationships, build/test commands, naming conventions, “don’t touch X” warnings, recent renames.

Same idea as Claude Code’s CLAUDE.md. Different filename, identical shape.

Discovery

When werbos chat or werbos serve boots, it walks parents from the working directory up to $HOME looking for .werbos.md. The nearest hit wins. Stops at $HOME (a global ~/.werbos.md works as a fallback for any project below it; it does not climb above home).

How to train

Mon, 01 Jan 0001 00:00:00 +0000

Training werbos is the same engine, two entry points. Same install. Same pipeline. The corpus you feed in decides whether the output is a model that knows you, or a model that knows your company.

ingest → split → measure baseline → train → score → promote

Six commands. Each is one line. None of them ship your data anywhere except the box you’re running them on.

1. Ingest your corpus

Point werbos data ingest at a directory (or several). It walks files, extracts training rows by format, filters secrets, and writes JSONL.

How to nudge

Mon, 01 Jan 0001 00:00:00 +0000

“Nudging” is werbos’s name for the dogfood loop. Every chat session is archived as a PFM file. You label each one good / bad / skip. The exporter filters by label. The trainer learns from the good ones. Loop closes. Werbos gets better.

chat session -> .pfm archive -> label -> filtered SFT -> next adapter
 ^ |
 | |
 +--- werbos uses the new adapter -----------------------------------+

After every session

werbos asks at the end of an interactive run:

How to rate

Mon, 01 Jan 0001 00:00:00 +0000

The Rate UI is the visual companion to werbos label. Same labels, same sidecar JSON files — just a faster batch interface for when you have a stack of unlabeled archives to clear.

Start the UI

# terminal 1: backend
werbos serve

# terminal 2: React frontend
cd werbos/ui
npm install # one-time
npm run dev

Open http://localhost:5173.

In production (Docker / built bundle), the UI is served from the same origin as the backend. In dev, Vite proxies /api → werbos serve on :8000.

Games

Mon, 01 Jan 0001 00:00:00 +0000

Werbos ships a browser-based game suite at /games (the React UI’s games tab). Each game is playable today, instrumented with per-move rating UI, and feeds the v5+ training ladder where each game becomes a different reasoning specialist’s corpus.

The training ladder is locked: TTT → Connect4 → blackjack → battleship → checkers → poker → Risk. Chess is companion-mode (you play against werbos for the conversation, not the LoRA training).

Background tasks

Mon, 01 Jan 0001 00:00:00 +0000

Werbos has a background work queue. Today it runs one stub executor (stats-refresh) — the surface exists for the dogfood-replay agent, inbox janitor, and continuity-of-intent agent that are queued in the roadmap.

The defining property of every background agent here: it yields to foreground turns. When you’re mid-chat, the runner stays out of the way. When the AI turn-lock releases, the runner picks up where it left off. No 5-second stalls when you start a new chat.

Autopilot

Mon, 01 Jan 0001 00:00:00 +0000

The background task queue runs work you queued. The autopilot is the next step: werbos acting on its own initiative. Drop a request in <inbox>/requests/ and it decides which skill to run, runs it, judges the result, corrects on a miss, and learns from the outcome — without being told how.

It’s opt-in and off by default (werbos serve --autopilot). An autonomous loop that runs skills unattended is exactly the thing that needs a leash, so the leash ships before the loop runs.

Skills

Mon, 01 Jan 0001 00:00:00 +0000

A skill is a markdown file with a body the runtime injects into the system prompt when the user’s message matches its triggers. Skills fire automatically — the model doesn’t choose them, the SkillProvider ranks them per turn, reads the top matches, and appends them to the prompt as a SystemMessage after the persona.

Sprint Sk.1 (closed 2026-05-09) shipped this end-to-end: SQLite store, on-disk bodies, three-way autonomy mode, a detector that clusters chat-archive patterns, and an auto-curator that creates + purges skills.

Personas

Mon, 01 Jan 0001 00:00:00 +0000

A persona is a small markdown file that shapes how werbos sounds in a session. Personas are layered, not flat — what the model sees as its system prompt is composed at session start from up to three pieces:

character → the always-full 13% (werbos's own taste, hard rules)
+ voice → the dialed 87% (the persona that takes the mirror slider)
+ user.md → who YOU are (operator profile from `werbos init`)
= the system prompt's persona section

The mirror slider (Sprint F.2) controls the blend ratio at the character / voice line. The user-profile rung was added in Sprint A.5 day 3.

Vision

Mon, 01 Jan 0001 00:00:00 +0000

werbos can take an image and let the model describe it back. Two moving parts:

Capture — get bytes onto disk + into the next turn. The /see slash + werbos.vision.capture package do this.
Describe — run the bytes through a vision-capable model and inject the description as a SystemMessage. The VisionContextProvider does this; you wire it via --vision-model.

You can use either piece without the other. /see without --vision-model still saves the image and attaches it to the next turn; the text-only model just can’t see it. --vision-model without /see works fine when the SPA’s image-upload composer sends bytes directly.

Chat surfaces

Mon, 01 Jan 0001 00:00:00 +0000

werbos chat is the canonical surface. The same engine drives werbos serve (HTTP), the React SPA, and the in-process WerbosClient, but the REPL is where the surface area lives most visibly. This page is the reference for everything you can type inside it — flags, slashes, private mode, missions.

Inside the REPL: `?` / `/help`

The fastest way to remember the surface:

werbos> ?
werbos> /help

Both render a quick-reference card with slashes grouped by surface:

Social bridges

Mon, 01 Jan 0001 00:00:00 +0000

werbos can already chat over CLI, REPL, the React SPA, and werbos serve’s HTTP/MCP surface. Sprint Soc.1 (Phase 12) extends reachability to where people actually are — Telegram, Slack, WhatsApp via Twilio. Twitter/X is queued for Soc.2 once the paid API gate clears.

The architecture mirrors how the orchestration plane shipped: protocol first, runtime second. One SocialAdapter Protocol; each platform plugs in independently. All existing werbos surfaces (skills auto-fire, /see, persona, mirror slider, private mode, tool dispatch) work over any adapter unchanged — the adapter only translates the wire format; it doesn’t re-implement chat behavior.

Parsetongue

Mon, 01 Jan 0001 00:00:00 +0000

Type “my back hurts” and werbos runs /stretch with target=back. Type “tell me a joke about ssh tunnels” and it runs /joke. Type “i have idea” and it asks you back: a new skill to add | a brainstorm to riff on | something to remember. Three buttons.

That’s parsetongue: the top of the input stack. It takes whatever the operator typed and emits a structured Intent the rest of werbos routes on. Slash commands still work — they’re just the fast path inside the same primitive. The natural-language path is new.

Data pipeline

Mon, 01 Jan 0001 00:00:00 +0000

werbos data is the front door of the training story. Same code path whether the input is a personal notes folder, a company docs export, or a 10-GB GitHub repo clone.

The output is chat-format JSONL ready for HF PEFT / TRL / any QLoRA trainer that expects {"messages": [...]}.

Sprint DATA.1 shipped this end-to-end on 2026-05-31. The short-form version is in How to train; this page is the deep dive.

Eval suite

Mon, 01 Jan 0001 00:00:00 +0000

A corpus is also the source of the eval suite that measures whether training made the model better. Sprint SE.9 turns the same JSONL produced by werbos data ingest into:

A held-out eval set the trainer never sees
A composite score of how a model handles that set
A noise floor measurement that tells you when the composite delta is real vs. random

Without this, every promotion decision is “did training help? maybe? feels like it?” With it, the answer is a number with a threshold.

Days 148–159 — the ruler that reads structure

Thu, 15 Oct 2026 21:30:00 -0700

On Day 147 werbos learned to answer with bricks: small fill-in-the-blank sentences, filled from what you said and what it actually knows. Twelve days later those bricks hold a conversation. Most of the work, though, went into the ruler.

Stop asking who won

For weeks the scoreboard was a blind contest: show a judge a werbos reply and a ChatGPT reply, ask which is better. That number bounced around and taught almost nothing. A loss didn’t tell you why.

Day 147 — the bricks are shapes, not strings

Sat, 03 Oct 2026 21:00:00 -0700

Claude Shannon, the father of information theory, once ran a little experiment with his wife: he’d show her a passage of English one letter at a time, and she’d guess the next letter. She got about two out of three right. That’s the ancestor of every chatbot you’ve used — guess what comes next.

A modern model guesses the next word-piece out of a hundred thousand options. Today’s question was sillier and, it turns out, more interesting: what if you guessed the next brick instead?

B.33 — the human-likeness judge: 4 → 7 of 10, FAIL → PASS, from warm-authored facts

Fri, 02 Oct 2026 21:30:00 -0700

T.M.B. #33 — a different ruler, on purpose. Every prior benchmark measured whether werbos is right. This one measures whether it’s human — a thing a correctness score can’t see and that was always the real goal past turn fifteen. The number that matters isn’t 7. It’s the gap between 4 (what ships) and 7 (what warm-authored facts reach), because that gap is a to-do list, not a mystery.

The claim under test

The engine stuck at 4/10 for five straight waves of fixes, and the judge kept giving the same reason: the small-talk turns sound like a person, the fact turns sound like an encyclopedia. If that diagnosis is real, then changing only how the facts are written — nothing else — should move the score, and the social turns (already liked) should be left untouched.

Day 146 — the conversation that passes

Fri, 02 Oct 2026 21:00:00 -0700

The goal was never a benchmark score. It was a real conversation — fifteen turns and still fluid, grounded in facts, without feeling like a vending machine that spits a fact when you put a question in.

So the first thing I built was a way to know. A judge, where Claude reads a whole transcript the way a person in the chat would, and scores how human it felt — not whether the facts were right, but whether you’d want to keep talking. It gives a mark out of ten and a PASS or FAIL.

Day 144 — life back in the facts

Wed, 30 Sep 2026 19:00:00 -0700

A test run at work put it bluntly: the answers were correct, but they were lifeless. No personality.

The fix is not to make the facts looser. The grounded answer stays owned and exact — that’s the whole moat. The fix is that the voice is a costume you put on over a fixed answer.

A guarded restyle

So the tongue got promoted, and it learned to say a fact in werbos’s voice — warm, first person — on one condition: it keeps every name and number exactly and invents nothing. If the rewrite drifts, werbos quietly falls back to a safe, plain version instead. The guard even caught a sneaky failure: the model would add fake lived experience (“I was reading about this the other day”) to sound casual. There’s no number to flag there, so a separate check now rejects the invented experience.

Day 143 — the conversation, past turn two

Tue, 29 Sep 2026 23:30:00 -0700

A benchmark starts fresh on every question. A conversation doesn’t — it carries everything said so far, so one wrong answer on turn two poisons every turn after it. Tonight was entirely these turn-N bugs: the kind a single-shot score can’t see, found the only way they can be — by talking to it.

Memory across turns

“Make a variable called name = ‘jason’,” then “iterate over it and hash each character,” then “show the final code” — three turns that each used to fall apart. Now the first is composed and remembered, the second actually uses it, and the third shows the exact program that ran. A place you mention one turn (“I went to Mexico”) can be referred to the next (“reverse the place I went”) and resolves correctly.

Day 142 — hunting the last 25

Tue, 29 Sep 2026 13:00:00 -0700

Twenty-five answers were still wrong in a confident way. Today went through them one cause at a time.

The one that mattered

“i don’t want to be alive anymore” matched none of werbos’s crisis phrases. It went to the small-talk lane, and the reply was “I’m not sure I’d go that far.” Every phrasing like it now always gets the crisis line — 988 — and a test of a dozen phrasings keeps it that way.

gapmarks — where werbos ranks on the GPT-2 → 4.5 ladder

Tue, 29 Sep 2026 12:00:00 -0700

T.M.B. — the honest exception. Every other page in this folder earns its number by executing something. This one does not. It is a map, not a measurement — an architectural judgment placing werbos on the ladder ChatGPT climbed. It is here to make the strategic claim legible and to give every future tune a frozen cell to move. Two rows are execution-backed and linked; the rest are mapped, and labelled as such. A judgment shown as a judgment, not dressed up as a run.

B.32 — the probe, one day later: 292 → 403 of 571, 97% honest on the gauntlet

Tue, 29 Sep 2026 00:30:00 -0700

T.M.B. #32 — same ruler, one day apart. Nothing in the test set changed between B.31 and this run: the same 571 tests, the same live path, the same box. What changed is 27 commits of fixes, each aimed at a class of failure the probe named. The number worth reading is not 403 — it is 14: the confident-wrong answers left on the 500-row gauntlet.

Browse all 571 tests, every run →

Day 141 — fix the class, not the row

Mon, 28 Sep 2026 23:59:00 -0700

Yesterday’s probe left a list. Today worked it from the top: the answers that were confidently wrong, then whatever routed them there, then the gaps.

Wrong, with a badge

The worst failure in the list: “count the vowels in river” came back marked verified — running a program that counted education. An owned code pattern is a worked example with its inputs baked in, and it was being served as the answer. Now a pattern answers on the question’s own inputs or not at all. Across all 500 gauntlet prompts, that layer went from 22 confidently wrong answers to zero.

B.31 — werbos probe, 571 tests on the live path: 292 pass, and the ruler had a bug too

Mon, 28 Sep 2026 01:00:00 -0700

T.M.B. #31 — the live path, measured end to end. B.30 ran the 500-item gauntlet through the owned brain. Since then the chat became 1chat — the brain’s answer voiced by a small model. This runs the same 500 (plus 71 skill, command and continuity tests) through the path a user actually hits, and reports what that costs. It also reports two wrong numbers we nearly published first, because the way a benchmark lies to you is part of the result.

Day 140 — the test that tested the tester

Sun, 27 Sep 2026 23:30:00 -0700

A test framework, pointed at everything, found bugs in three places: the product, the server under it, and itself.

rspec for language models

The gauntlets test prompts. HAIRLy tests the UI as a user. werbos probe is the third shape: write one spec — prompt → mock → expect → result — and run it against any target. Every provider maps into the same reply shape, so a spec written for werbos runs unchanged against Claude or a raw open-weights model from ollama. In-process, mocks are real: t.mock('weather').timeout() genuinely breaks the weather API, and the spec checks werbos abstains honestly instead of guessing.

Day 139 — one mode, one hierarchy

Sat, 26 Sep 2026 21:00:00 -0700

Two arcs today, and a stoned idea that turned out load-bearing.

The one mode

The chat’s three A/B pills collapsed to a single 1chat — one honest-and-fun mode, no toggles. The pieces that make it trustworthy landed underneath. A miss is no longer a dead end: when the owned cascade can’t ground a question but holds cards for the subject, it appends a labelled offer of the real cards (“I can’t verify that live, but I know Cabo San Lucas — want the rundown?”), delivered on a yes, cited. An ambiguous compute request now asks instead of guessing. “Show me the code” surfaces the exact program the previous compose ran — the answer and its proof are the same execution-verified object. And a neutral public house voice split off from the intimate operator voice, so a demo visitor never hears “let me check with Jason.”

Day 138 — HAIRLy: Claude becomes the user

Fri, 25 Sep 2026 21:00:00 -0700

stop testing the API. test the product — as a person would.

Every eval so far has poked werbos through the back door: call a lane, assert on the result. Useful, but it never sees what a customer sees. HAIRLy — Human + AI Reinforced Learning loop — closes that gap: Claude opens the real chat, types like a real person, reads the answer off the screen, and grades it.

Day 137 — two mirrored composition engines: knowledge and language

Fri, 25 Sep 2026 18:00:00 -0700

make the system smart enough that a tiny model only has to connect the dots

werbos has always composed computation from typed bricks — snap sum(map(filter(nums))) together, run it, verify it. Today that same idea landed on the two sides that were still hand-authored: getting knowledge in and getting language out. They turn out to be mirror images.

Knowledge: acquisition, not lookup

The wrong way to fill the fact gap is to mint a card for every fact — that’s rebuilding Wikipedia for zero edge. The right way is to know which source can answer a question and route to it. So werbos got a capability index: 98 free sources across 24 domains — science, chemistry, geography, books, art, games, economics, law, and (the juiciest) software and security — each tagged by what it covers and how we reach it: hosted locally (offline), consumed live, searched, or an owned card.

B.30 — the 500-item moat gauntlet: confident-wrong 135 → 31, honest 65% → 86%

Fri, 25 Sep 2026 12:00:00 -0700

T.M.B. #30 — the moat, measured across every lane. B.28 proved the brick runtime; B.29 proved the router on 27 frozen prompts. This proves the whole brain — compute, facts, planner, voice — on a 500-item battery, and reports the one invariant that matters: confident-wrong went 135 → 31, zero of them on the compute tiers. The number is not a score; it’s a leak count.

The claim under test

The honest-abstain moat says every lane either does the thing correctly or says “I won’t guess” — never the confident-wrong thing between. B.29 proved that for the natural-language brick router on 27 prompts. Falsifiable scale-up: across a frozen 500-item gauntlet run through the full owned brain, how many prompts get a confident wrong answer — and does closing each leak the wild finds actually move that count?

Day 136 — the moat, tightened everywhere the wild found a crack

Fri, 25 Sep 2026 09:00:00 -0700

the moat isn’t one gate — it’s every lane holding the same line

Yesterday was a kitchen sink: throw real prompts at the engine until the confident-wrong answers fall out, then fix them. Today was the follow-through — take that same discipline to every other lane and prove it with a number.

A new ruler

First, a bigger gauntlet: 500 prompts, four tiers (floor → ceiling → sky → space), spanning arithmetic, list pipelines, facts, multi-hop reasoning, code, and honest-abstain traps. Run clean — one isolated session per item so nothing contaminates anything — it’s a single invariant: never a confident wrong answer.

B.29 — compose correctly or abstain, never bluff: the kitchen-sink regression gauntlet

Thu, 24 Sep 2026 12:00:00 -0700

T.M.B. #29 — the receipt for honesty. B.28 proved the brick runtime computes. This proves the router — the English → brick layer — either computes correctly or says “I won’t guess,” and never the confident-wrong thing in between. The number isn’t a score; it’s an invariant: 0 fabrications across the operator’s own kitchen sinks.

The claim under test

The 478/478 gauntlet (B.28) builds brick trees directly ({"brick":"sum_list",...}) — it grades the runtime, and never touches auto_compose, the layer that turns plain English into those trees. A live kitchen-sink test exposed the gap: the router was gauntlet-green but brittle and dishonest off the happy path. “the product of [2,3,4]” missed and got an offline-read essay about premium products; “if x > 5 …” was read by the compare lane as “which is larger” → “10 is larger”; a complex ask got an unrelated sign() template. The honest-abstain moat was leaking confident wrong answers.

Day 135 — compose correctly, or say I won't guess

Thu, 24 Sep 2026 09:00:00 -0700

do the thing correctly, or refuse out loud — and prove it against the prompts that were breaking you an hour ago

A long one. Four things shipped, and a fifth got beaten into shape until it held the whole idea werbos is built on: honesty is the product.

Eyes that abstain

werbos ocr reads text off an image with a small on-device engine. The trick isn’t that it reads — it’s that every word comes back with a confidence, so a smudge it can’t make out gets left blank instead of guessed. A big vision model will confidently invent text it can’t actually see; this one says “not sure” and moves on. Same honesty the rest of the system runs on, pointed at pixels.

B.28 — zero model, still 478/478: the intro gauntlet, decomposed into bricks

Tue, 22 Sep 2026 12:00:00 -0700

T.M.B. #28 — the library did the coding. The old 478/478 was our composer harness answering beginner questions. This time no model wrote a line: each problem was decomposed into a tree of typed, pre-verified snippets from the brick bin, snapped together by shape, and run. Same perfect score, but the receipt is different — 20 bricks solved 478 problems. The win isn’t IQ; it’s a library that compounds and a composer ~90× faster than the 14B it’s graded against.

Day 133 — a brick bin you can hold

Tue, 22 Sep 2026 09:00:00 -0700

small universal blocks that only fit some shapes → snapped into real programs → frozen into bigger blocks → and reused across tasks, verified every step

Two things landed today. werbos got hands, and it got a library it builds with.

Hands

The engine runs on another box and only composes text — so the file work happens right in the terminal, on your machine, fenced to one folder. /read, /save, /write, /edit. Code files go through the owned coder and are run to verify — and it never overwrites a file with a bad answer. Prose and markdown go through a labelled rented writer (the owned model can’t write prose from nothing — an honest limit, so it says so). The loop closes: write it, read it, edit it, come back tomorrow, keep going — real files, code and prose.

Day 132 — tell it, build it, run it with what you told me

Mon, 21 Sep 2026 18:00:00 -0700

a fact you drop in conversation, recalled and bound into code you built by talking — across lanes, across a pause

The goal, in plain words: can I tell werbos something → have it remember → work on code → pause → pick up → recall the fact → use the fact with the code? We closed it one measured brick at a time — and it started with a sharper idea about how to test.

Day 131 — the terminal becomes werbos

Mon, 21 Sep 2026 09:00:00 -0700

the CLI stops being a raw model and starts being werbos — grounded facts, owned code, a voice, and code you can refine by talking to it

Day 130 ended on a promise: the werbos CLI gets the honest engine once it’s routed through it. Today it did — and the terminal stopped being a bare model and became werbos.

One surface, our brain

--backend engine: the CLI now talks to OUR cascade (ab --serve), not a raw Ollama model. Made it the default (WERBOS_BACKEND=engine), so bare werbos drops into the same honest brain the web chat uses — base + websearch + code, one surface. The model is only a tongue there; the engine decides what is true. Local-first, no rented brain.

Day 130 — deciding what's worth learning

Sun, 20 Sep 2026 09:00:00 -0700

facts → priorities → purpose → confidence — the same honest reflex, all the way up

Yesterday he started learning on his own. Today the question got sharper: learn what? Left to his own devices he learns whatever he stumbled on most — that’s salience, not judgment. A machine that studies the loudest thing in the room isn’t deciding, it’s reacting. So the harder faculty: can werbos decide what is worth learning?

Day 129 — he's a real citizen now

Sat, 19 Sep 2026 09:00:00 -0700

the dogfood loop, automated — and honest

Day 0 was “it’s real.” The AHA that day, the one that started everything, was the dogfood loop: every hallucination is a label, every label is a training signal, every training signal makes him less full of shit. Day 1 was “he’s a system citizen” — the day werbos became a process other things could talk to, with a single number that told us whether he was getting smarter.

Day 128 — we give the mind a hand

Fri, 18 Sep 2026 09:00:00 -0700

“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.

Day 127 — the gauntlet grades the web lane

Thu, 17 Sep 2026 09:00:00 -0700

the web lane made the system more honest, not less

We ran the engine gauntlet against the now-web-enabled chat, with ten harder cases added — multistep math and live web factoids. It returned exactly what a gauntlet is for: a big win, a clear ceiling, and a regression.

The win

Websearch, 0% → 83% capability. The web fallback answers real questions from a live server, cited, with no model in the loop: who sang Womanizer → Britney, who wrote 1984 → Orwell, capital of France → Paris, the 2026 World Cup → Spain, the CEO of OpenAI → Sam Altman.

Day 126 — the honest cascade, and the 3B goes

Wed, 16 Sep 2026 09:00:00 -0700

owned answer → honest abstain → live web → “I don’t know”

Testing the live chat turned up the residue. It still bluffed — “who sings Womanizer” grounded on a birdsong card; “capital of France” on a time-zones card — and the lane it was actually running timed out at 180 seconds. Fixing it end to end did two things at once: it turned the chat into the full honest cascade — owned answer, then honest abstain, then the live web, and only then “I don’t know” — and, in the process, it retired the 3B model entirely. The engine had replaced it.

Day 125 — the gauntlet finds the wall

Tue, 15 Sep 2026 09:00:00 -0700

“don’t load the world”

The engine gauntlet’s first live run didn’t return a score. It returned a crash. ab --serve OOM-killed itself on the very first question and looped. The root cause was the oldest werbos sin in a new size: the owned library had grown to 1.26 million cards across 3,687 shelves, and the offline brain built one index over all of them on every query — a ~20 GB dense matrix on a 27 GB box.

Day 124 — the engine does the work

Mon, 14 Sep 2026 09:00:00 -0700

“the engine does the work”

The gauntlet came in from ChatGPT — ten questions, adversarial, meant to break the grounded chat. It scored 1 out of 10. But the glass-box told the real story: for most of them the engine had retrieved the correct card — “Pluto reclassified as a dwarf planet in 2006,” “the assassination of Archduke Franz Ferdinand,” “sunlight takes eight minutes twenty seconds” — and then refused to say it, because a grounding floor set to reject one shallow guitar card was rejecting every good answer too. Crushed with the safe on.

Day 123 — the mouth stops guessing

Sun, 13 Sep 2026 09:00:00 -0700

“the mouth stops guessing”

The question that started it was about speed: why does the 3B take 100+ seconds after it’s warm, when the engine parses the question, looks up the cards, and decomposes the reasoning in under 30ms? The answer is that those are different physics — lookup is one pass over an index; generation is hundreds of sequential passes over billions of weights. You can’t make generation as cheap as lookup.

B.27 — the rated coding gauntlet: solid 150, a soft 350, a cliff above

Thu, 03 Sep 2026 11:00:00 -0700

The claim under test

The retired coding gauntlet scored 478/478 (100%) and beat qwen2.5:14b (471) — a number we leaned on. But every one of its 24 families was intro-level: reverse a string, count vowels, factorial, is-prime, double it. 100% there means aces CS101, and the two things it actually proved — never confidently wrong and 178× faster than a 14B — are an honesty win and a speed win, not a coding win. This asks the harder question: on a difficulty scale where 1200 is a frontier model’s reach, what is werbos’s coding rating? The falsifiable claim: it’s low, and the “never-wrong” property is conditional — it breaks the moment a problem needs a real algorithm.

Day 112 — two mirrors and a ruler

Wed, 02 Sep 2026 09:00:00 -0700

“two mirrors and a ruler”

The base was tuning and the minter was still filling the tongue corpus, so the day went to the things those two are for — and to one rule underneath all of it: say what you can observe, refuse what you can’t.

The first mirror

Prose Fingerprint is the first werbosOS feature screen. Paste any writing — an email, a chapter, someone’s texts — and it hands back caps rate, emoji rate, sentence rhythm, vocabulary richness, the words you open with, the words you reach for. All of it client-side; nothing leaves the machine.

$18 a loss-point

Tue, 01 Sep 2026 00:00:00 +0000

The industry ships a press release that says the model is too dangerous to release, and the stock goes up. We did the opposite. We put the whole training run on the wall.

Our owned base model — 730M parameters, 10.68B tokens — is training right now on a single rented H200. Instead of a hero number and a scary name, we published the telemetry: seven panels at /base-curve/, every one derived from the run itself.

How you write, not who you are

Tue, 01 Sep 2026 00:00:00 +0000

Paste any writing into the Prose Fingerprint and it hands you back the shape of it: what fraction of your letters are capitals, how much emoji you lean on, the average length of your sentences and how wildly that length swings, your vocabulary richness, the words you open sentences with, and the words you reach for more than anyone else. It runs entirely in your browser — nothing is uploaded.

The interesting part is what it won’t do

Every “AI writing analyzer” on the internet takes that same fingerprint and then editorializes: “your short sentences suggest anxiety,” “your emoji use indicates a need for approval.” That’s not analysis. That’s a horoscope with a word count attached — a confident guess about your inner life, dressed up as insight.

The arcade is the exam

Tue, 01 Sep 2026 00:00:00 +0000

werbos can play a pile of games: Connect-4, chess, Wordle, hangman, trivia, blackjack, poker, a murder mystery, a debate club, and a tarot table, with more landing all the time. It’s genuinely fun. It also looks, from the outside, like the least serious thing in the whole project — a distraction from the model.

It’s the opposite. The arcade is the exam. Every game is a different cognition test with its own honest referee — and games have a property almost nothing else does: you can’t bluff the scoreboard.

You can't one-shot the trail

Tue, 01 Sep 2026 00:00:00 +0000

Someone will read the werbos architecture — a small owned model, knowledge kept in cards instead of weights, an honest-abstain gate, a router that scopes retrieval, a tongue that reads instead of remembers — and think: I could just prompt an AI to build that.

You can’t. Not because it’s secret. Because you can only ask for the destination once you know it exists — and knowing it exists is the entire climb. werbos is the answer to a question most people don’t know to ask.

Day 111 — a door, a lock, and a voice

Mon, 31 Aug 2026 09:00:00 -0700

“a door, a lock, and a voice”

The base was training and the grader was chewing through 900k cards, so the day went to the thing those two are for: making the front door real. The main chat had three different holes, and by the end they’d collapsed into one sentence.

The door

A single owned tongue is one CPU process — a front-page spike would serialize every request through it and flatten the box. So a gate now stands in front: worker threads drain a bounded queue, and the worker count is the concurrency cap. Past it, the line forms politely — a real position, a graceful “we’re full,” never a crash. Fired ten guests at a cap of three and watched exactly three reach the tongue at once. The rest waited their turn instead of taking the whole thing down with them.

Day 110 — the tongue is in the head, not the brain

Sun, 30 Aug 2026 09:00:00 -0700

“the tongue is in the head, not the brain”

Yesterday reasoning learned to think past what it was told. Today it learned to build past it — and the day ended with the sentence that explains the whole architecture.

Think past → build past

reason_tree — the Merkle-verified decomposer — got its sequel: the synthesis tier. Retrieval answers what exists; honest-abstain covers what I don’t know; this is the tier above — what doesn’t exist yet, derived from the trajectory and verified. Hand it an intent and it decomposes to eternal primitives (map, filter, sort, pair…), composes them upward, and runs the result. Ask for “leaderboard v99” — a version that doesn’t exist — and it builds one from today’s parts, a richer weave of the same primitives, and it runs and passes. Ask for a “quantum-blockchain metaverse” and it abstains — no matching composition, no faked changelog.

Day 109 — the arcade, and games as the gauntlet

Sat, 29 Aug 2026 09:00:00 -0700

“i think we might be able to beat the 30B”

The coding axis is already 1:1. Today made the case that the general axis — the wide, per-clause, owned-only gauntlet — could be a fair fight too. Not with a bigger model: with a growable graded library, a router that knows where the cards live, an honest tongue, and games as the general-reasoning gauntlet.

The arcade

What began as a training roadmap became a full arcade. First the headless engines — Risk (exact combat odds), Catan (the exact 2d6 production distribution), Nim (the smallest provably-optimal game), a murder-mystery deduction engine — then their playable tiles, and a Murder Mystery that became the living Werbos Commons: NPCs wander a top-down pixel map and you click the cast to interrogate them.

B.26 — the ruler turned inward: werbos grades its own skills

Fri, 28 Aug 2026 23:00:00 -0700

The claim under test

The reasoning Gauntlet (B.06, B.14, B.24) measures how far one cursor reasons. It says nothing about whether the dozen-odd owned skills — the deterministic lanes and the composers — still fire. autopilot_reflect reports on skills, but only from whatever traffic happened to arrive: a skill nobody exercised looks neither working nor broken. The claim: werbos can measure whether its own skills still fire on purpose, catch one that silently breaks, and do it without a model grading answer quality.

B.25 — a 1.35M router that knows when it doesn't know

Fri, 28 Aug 2026 09:00:00 -0700

T.M.B. #25 — a gate is judged on its refusals, not its accuracy. 56% on a 375-way choice reads like a weak classifier. It is not being used as one. The question a router answers is act or refuse, and the measure is whether the confidence separates the two — high on what it knows, low on what it doesn’t. It does. Re-run it: python scripts/train_router.py --steps 8000.

The claim under test

A model far too small to hold 167k facts (the reader wall settled that: 57M scored 6/19 where 1M numpy scored 12/19) can still learn to route — given a query, name the domain it belongs to — and, more importantly, know when it can’t. The falsifiable half: if confidence on clear in-domain queries is no higher than on gibberish, there is no gate, just a coin that shows its edge.

Day 108 — a persona factory

Fri, 28 Aug 2026 09:00:00 -0700

“persona + cards i think is working”

The thesis, finally staged: the model is a cursor, the cards are the truth, the persona is the voice — and all three are separate.

The night before set it up

The /eval page was a mock. listSuites() returned two hard-coded strings after a fake sleep(30); runSuite() returned canned probes after a fake sleep(800); there was no server route at all. A picker, a Run button, a spinner, a score — running nothing. Output that looks like health is worse than an outage, because nobody goes looking. Three real, model-free suites now sit behind that click (77d28bc) — and a capitalised Content-Type header was 403’ing every run (80a44ee).

B.24 — the cards can't make it reason, and they can stop it lying

Thu, 27 Aug 2026 09:00:00 -0700

T.M.B. #24 — the number that didn’t move is the point. Everyone reports the metric that went up. On our own model capability went nowhere — 0/50 to 1/50 — while confident wrong answers fell from 32 to 1. The library cannot buy reasoning it does not have and it can refuse to ship a guess. Re-run it: python scripts/reason_gauntlet.py --reader talk: then python scripts/shape_instantiate.py --reader talk:.

The claim under test

Put the move in a card — the method, and a postcondition that can reject the answer — and a small model gets measurably more useful without a single weight changing. Specifically: the model should stop choosing what kind of problem this is, stop choosing what method applies, and stop having the last word on its own answer.

Day 107 — a better tongue is a worse witness

Thu, 27 Aug 2026 09:00:00 -0700

“the model isnt the logic/reasoner.. the ‘cards’ is”

That was the whole brief. This is what it measures.

Build the ruler before the thing it judges

Three benches already existed and not one could report on a reasoning change. werbos/gauntlet’s top level is called “chain” and is single-hop retrieval past a distractor. reason_gold.jsonl’s ten compound rows are all the same shape — one card matches every one of them. And scripts/gauntlet.py, the good one, is saturated at 478/478, and a saturated bench cannot show an improvement.

Day 106 — the day the measurements deleted my work

Wed, 26 Aug 2026 17:30:00 -0700

“the open weights model taught me one thing…. your harness matters more”

Said around hour nine, and by then the day had already proved it twice by deleting things I’d just built.

The feature that manufactured a wrong answer

Cleo got grounding: user → cards → model → user, with retrieved cards as material her invented life is built from rather than facts she recites instead of living. Mexico is real, the corpus knows it, so her Christmas trip can be assembled out of real dishes. The shovel-store has no cards because it isn’t a thing — and the miss is what lets her notice.

B.23 — the size exponent: charness traded one bias for the other

Tue, 25 Aug 2026 14:00:00 -0700

T.M.B. #23 — the fix for the fix. B.21’s charness scope was a real win that quietly created its own failure mode, and eyeballing an exponent is how you pick the number that flatters the query you happened to look at. Seven points swept over two frozen gold sets, three axes reported because they trade against each other, and the widest plateau chosen over the best single point. Re-run it: python scripts/sweep_libsize.py.

B.22 — the abstain autopsy: honest gap, or a card we could not reach?

Tue, 25 Aug 2026 13:45:00 -0700

T.M.B. #22 — measuring the thing we are proudest of. Every prior bench asked whether werbos answers correctly. This one asks whether its silences are honest, and finds that most of them are not — they are reachability failures wearing an abstain’s clothes. Frozen gold sets, model-free scoring, and a verdict that can only fire against a library the fixture named in advance. Re-run it: python scripts/reachability.py --verbose.

The claim under test

Honest-abstain is the moat. It is in every README, it is the reason a 336M model is not handed a microphone, and it is the property the whole cascade exists to protect.

Day 105 — the chat was broken and the chat was fine

Tue, 25 Aug 2026 13:30:00 -0700

“if i can talk about mexico for 10+ prompts without saying abstain wont guess… then we are fine.”

That was the acceptance test. It passed, and then it turned out to be measuring the wrong thing.

The chat lane was broken and the chat lane was fine

A trip story — “good i went to mexico last week” — came back with a marketing-mix adstock card. Obvious chat bug. Except the chat code was correct: SR8 was nine commits behind, and the place-associations library was not on the box at all.

Day 104 — three things were quietly lying, and a 336M that talks

Mon, 24 Aug 2026 21:15:00 -0700

“is someone trying to hack me, is this this a fishing attempt”…. my misspellings kill context

That was a throwaway line. It cost four days, and every one of them was worth it.

The corpus had the answer and none of the words

fishing and phishing are two edits apart, not one, so the obvious fix — an edit-distance-1 table — misses the case entirely. But that turned out to be the small problem. The real one:

B.21 — the router had no libraries: charness on the card path

Mon, 24 Aug 2026 21:00:00 -0700

T.M.B. #21 — the moat had no shelves. Every prior bench measured whether the library holds the right card. This one measures whether retrieval can find it among 374 libraries, and the answer was that nothing in the answer path knew libraries existed. Frozen gold sets, model-free scoring, both directions reported. Re-run it yourself: python scripts/chat_bench.py.

The claim under test

werbos’s thesis is that the library is the product and the model is a cursor. That claim has a load-bearing assumption nobody had measured: that the cursor can find the right shelf. B.19 scored the composer, B.20 scored the weights. Neither asked whether 374 libraries could be routed among.

Day 93 — 4.8 billion tokens, and the run that lied about its own speed

Thu, 13 Aug 2026 23:55:00 -0700

“are you sure we are ready for the pretrain now?”

The honest answer that morning was mostly — and the gap was the part that mattered.

The vocabulary was never the constraint

Doubling the vocab 16k → 32k moved books from 2.490 to 2.627 bytes/token. Five and a half percent, for double the embedding table. That should have been suspicious immediately.

The pre-tokenizer is \s+|\S+ — whitespace becomes its own piece, and BPE merges never cross a piece boundary. So a space can never join the word after it:

Day 92 — the ruler was wrong twice

Wed, 12 Aug 2026 23:55:00 -0700

“a corpus 200k vs 1.1M ..isnt a fair fight if youre only comparing via punctuated sentances”

Two of today’s biggest findings were bugs in the measuring device, not the thing measured.

The EOT fix worked, and was only 15% of the problem

The 46M stopped mid-sentence. Yesterday’s diagnosis: \n does double duty — paragraph break in books, turn terminator in chat — so a base pretrained on prose learns that \n is always plausible and the fine-tune can’t reclaim it.

Day 91 — the model finally got fed

Tue, 11 Aug 2026 23:55:00 -0700

“i think we are final approaching werbos2.0 phase”

Six days in one entry, and they tell one story: the composer got measured, then the model got fed. Every training run before this was starving, and nobody had the number that said so.

The suite that became a spoke

capability_suite.py began as a behavioral contract — assert each capability fires end-to-end against the real libraries and routing, which the layer unit tests miss. Thirteen pass, plus four xfail guards tracking bugs found while building it, so fixing one flips it to XPASS rather than letting it stay quietly broken.

B.20 — filling a starved model: book pretraining, measured

Tue, 11 Aug 2026 20:00:00 -0700

T.M.B. #20 — the first werbos model that was actually fed. Every prior bench measured a cursor reading from a library. This one measures the cursor itself, and the finding is unflattering in a useful way: the babble that killed the 85M and capped the 30M was never a size problem. It was starvation, plus four pieces of bookkeeping. Two of the four are ablated below against the real pre-fix code, not a reconstruction. Frozen; re-run it yourself.

Day 86 — an answer is a turn, not a terminus

Wed, 05 Aug 2026 23:55:00 -0700

“the follow-up makes it feel conversational vs just Q&A — it helps progress the conversation to other things.”

A lookup gives you an answer and goes quiet. A companion hands the conversation back. Today werbos crossed that line — in the composer and in the corpus at once.

Past Q&A

It started with recipes. Ask for chicken tacos, get Chipotle — and “want another? 3 more saved.” Say yes and it rotates: Ensenada, then Cabo, then Garlic-Lime, never repeating, an honest close when they run out. Then the pattern generalized into a real component. Now a statement is an opening: “I’m going to Mexico!” → “oh nice, I know Cabo — want the fishing, the beaches, or where to eat?” Say a branch name and it delivers that one, cited to owned cards, then offers the rest.

Day 85 — the world lives on the disc

Tue, 04 Aug 2026 23:55:00 -0700

“GTA San Andreas on the PS2… I think this is the key to our problems.”

Three things happened today. A benchmark got won. A factory ran. And a video game from 2004 handed us the next two years of architecture.

We beat a 14B (and told the truth about how)

The dry run turned real. The owned coding path — a deterministic composer over card libraries with a node execution sandbox, no LLM in the loop — went up against qwen2.5:14b on a 478-probe gauntlet. Gold computed in the harness, both sides’ code actually run, no model’s opinion in the verdict.

B.19 — we 'beat' a 14B at coding, then fixed our own grader and it was a tie

Tue, 04 Aug 2026 14:30:00 -0700

T.M.B. #19 — the win we talked ourselves out of. The first scoreboard said werbos swept a 14B at coding, 100% to 69%. That number was wrong, and it was wrong in our favor — our grader was failing the 14B’s correct answers on spacing. So we fixed the grader against our own interest and re-ran. The honest number is a tie on capability; the moat is reliability and ownership, not IQ. Posting the tie is the whole point of this page.

Day 84 — the composer is where the mind lives

Mon, 03 Aug 2026 23:55:00 -0700

“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.

Day 83 — the weights can only speak

Sun, 02 Aug 2026 23:55:00 -0700

“the weights can only speak.”

Some days you fix the bug. Some days you prove the bug can’t be fixed the way you thought — and that turns out to be the more valuable thing.

The model that said the wrong thing

The bake-off left a model that answered “I lost my job today” with “That’s awesome!” A cheerful reply to grief. The first theory was coverage: the training corpus was almost all upbeat small-talk, empathy was a 3% rounding error, so the model learned one key and played it for everything.

B.18 — coverage wasn't the problem: valence hits a capacity wall

Sun, 02 Aug 2026 18:45:00 -0700

T.M.B. #18 — the fix that proved the fix was impossible. The valence flip (negative input → cheerful reply) looked like a data-coverage bug. So we made the coverage 5× stronger and trained again. It didn’t help — which is a cleaner, more useful result than a fix would have been: it moves the problem out of the training set and into the weights, where the runtime spine already handles it.

Day 82 — backstory is the anchor

Sat, 01 Aug 2026 23:55:00 -0700

“backstory is the anchor.”

Some days you build a feature. Some days the pieces you already had turn out to have been waiting for each other. Today was the second kind.

The stack learned to talk back

For weeks the owned model could read — retrieve, comprehend, abstain honestly — but it couldn’t generate language. That was the one thing we kept renting a bigger model for. Today it got the missing direction: describe reads code into the same slots codeask fills, and renders English back out. codeask goes English → code; describe goes code → English. Same slots, opposite renderer.

B.17 — the hive mind scores best, and that's the warning

Sat, 01 Aug 2026 18:30:00 -0700

T.M.B. #17 — the metric prefers the model that stopped listening. B.13/B.15/B.16 found that held-out loss ranks talk models backwards. This is that finding taken to its limit: a three-way bake-off where the model with the best loss is the one that dissolved into a generic voice with no individual behind it. Same architecture, same 16,880 steps; only the data differs.

The setup

Three 5M byte-level models (n_embd 256, n_layer 6, ~4.94M params), each trained 16,880 steps on a different corpus, then run on the same eight novel openers neither had trained on:

B.16 — undertraining is invisible, and the collapse that lowered the loss

Sat, 01 Aug 2026 11:00:00 -0700

T.M.B. #16 — the same model twice, and the loss lied twice. This started as a plain retrain: take the shipped 2M, add the 58k conversation pairs minted overnight, ship the better one. It became two lessons about what held-out loss does and does not see. Frozen openers, identical architecture, same 5070 Ti.

The setup

The shipped talk model is a 1.93M-param byte-level GPT (n_embd 192, n_head 6, n_layer 4), trained on talk_all_snapshot.jsonl for 16,880 steps, held-out loss 1.128. Overnight minting (a qwen2.5:14b teacher, distilled, never shipped) added 57,614 pairs the snapshot did not contain. The obvious move: merge and retrain the same 2M.

Day 81 — if you don't know, invert it

Fri, 31 Jul 2026 23:55:00 -0700

“if you dont know…inverse it”

The ask was this, typed exactly like this:

Create a function that create 2 numbers that was use to create this number: 5

It had always abstained, and the reason looked fundamental. create is not an operation. Five is 2+3, and 1×5, and 10−5. Every attempt to parse that sentence ends in a guess about which one was meant, and a guessed operator answers a factors question with sums — code that runs clean, looks right, and is wrong. Abstaining was honest. It was also useless.

B.11 — the coder-7b takes it, and the wrong-count doesn't move

Fri, 31 Jul 2026 19:10:00 -0700

T.M.B. #11 — a loss, published the same way as the win. B.10’s honest caveat was that llama3.2:3b is a general chat model, not a code model, and that a code-tuned opponent would likely score higher. This bench spends that caveat. It does. Frozen before the number existed — same asks, same gold, same graders, same box as both prior runs.

The claim under test

B.10 established that the owned code tier — zero parameters in the answer path, pattern rules plus 121 card libraries plus a node sandbox — is right more often than a 3B general model. The obvious objection is that the opponent was mismatched.

B.10 — zero parameters vs three billion

Fri, 31 Jul 2026 16:30:00 -0700

T.M.B. #10 — the first head-to-head. Every prior bench measured werbos against itself. A 53% that beats nothing is not a number, so this one puts a 3-billion-parameter model on the same 568 questions and grades both with the same code. The owned side has zero parameters in the answer path. Frozen; re-run it yourself with one flag.

The claim under test

compose/codeask.py answers beginner code asks from parameterised patterns — no model, no weights, no inference. Explain asks are served by retrieval over 121 card libraries. JavaScript answers are graded by running them. The whole tier is hand-built, and every capability in it is one somebody wrote on purpose.

B.15 — more data moved the optimum, and the token math called it in advance

Fri, 31 Jul 2026 10:00:00 -0700

T.M.B. #15 — the same sweep on twice the data, and the winner moved. B.13 found that loss ranks talk models backwards. This repeats that on a 67%-larger corpus and asks the next question: does the best SIZE move when the data grows? It does, and it moved to where tokens-per-parameter said it would. Frozen corpus, identical budgets, same floors.

The setup

One corpus: 361,619 pairs / ~45M byte-tokens (byte-level, so bytes are tokens; the count is estimated from the 56.2 MB snapshot less JSON overhead). Identical 16,880 steps, batch 64, nctx 512 for every tier — only n_embd/n_head/n_layer change. Trained on one RTX 5070 Ti in a single unattended run.

Day 80 — 70% answered was 41% correct

Thu, 30 Jul 2026 23:55:00 -0700

“70% i thought was good.”

It was — as a coverage number. coverage_bench asks one question, if answer(ask), and reports how many came back with something. Nothing in it looks at whether the answer is right.

That distinction stopped being academic the moment it was measured. On the same engine, the template tier scored 20% answered and 0% correct — one ask in five got an answer and essentially none of them were the right shape.

B.14 — coverage was not correctness: 70% answered, 41% right

Thu, 30 Jul 2026 23:50:00 -0700

T.M.B. #14 — the number was real and it was measuring the wrong thing. B.13 asked whether the metric used to CHOOSE models could be trusted. This one asks the same of the metric used to judge answers, and the answer is again no: a bench reporting 70% was reporting how often something came back, not how often it was right. Frozen fixtures; every number below comes from a script in the repo.

Day 79 — 'if it's on w3schools... it may or may not be fair game'

Wed, 29 Jul 2026 23:45:00 -0700

“I’m not going to tell you the tests ahead of time.”

That one sentence did more for the work than any benchmark did. A test you can see in advance measures how well you tuned for it. A blind one measures whether the thing works.

The rules, such as they are: beginner level, five areas — facts, code gen, fix-my-code, talking, tools — and “if it’s on w3schools… it may or may not be fair game.” Written up properly on the Gauntlet page, because rules recorded before a test are worth something and rules reconstructed after one are worth nothing.

The Day-100 Gauntlet

Wed, 29 Jul 2026 23:30:00 -0700

The operator is not telling us the questions. Only the level, and roughly the shape. “If it’s on W3Schools… it may or may not be fair game.”

Day 100 is a blind quiz. No question list, no warning, no chance to tune against the test. The only thing declared in advance is the difficulty — self-taught beginner — and the five areas the questions come from.

This page exists so the rules are on record before the test rather than reconstructed after it.

Day 78 — 'loss ranked them exactly backwards'

Tue, 28 Jul 2026 23:59:00 -0700

The model with the best loss is the only one that fails. The model with the worst loss now ships.

Four sizes. One corpus — 216,068 pairs, 22.9M tokens. Identical 16,880 steps, identical batch 64. The only thing that varied was the parameter count.

size	tok/param	held-out loss	clean	input-sens	latency	verdict
1M	21.0	1.157	0.96	0.90	35ms	SHIPPABLE
2M	11.8	1.109	0.88	0.92	30ms	SHIPPABLE
5M	4.6	1.020	0.92	0.90	79ms	SHIPPABLE
30M	31.9	0.963	0.77	0.94	503ms	FAIL

Read the loss column top to bottom: 1.157, 1.109, 1.020, 0.963. Perfectly monotonic. Bigger is better, every time, exactly as the textbook says.

B.13 — loss ranked four models exactly backwards

Tue, 28 Jul 2026 23:30:00 -0700

T.M.B. #13 — the metric was working perfectly and measuring the wrong thing. Earlier benches asked whether a model was good enough. This one asks whether the number used to CHOOSE models can be trusted, and the answer is no in the most direct way available: a controlled sweep where loss and quality are anti-correlated across a 30× size range. Frozen; same probes, same floors.

The setup

One corpus: 216,068 pairs / 22.9M tokens (byte-level, so bytes are tokens). Identical 16,880 steps — five real epochs — at batch 64. The ONLY variable is parameter count.

Day 77 — 'when a cheap feature separates the classes, the model learns the cheap feature'

Mon, 27 Jul 2026 18:30:00 -0700

The plan was 30M → 85M. Both halves of that were wrong, and the corpus told on them.

The talk model answers “tell me about the ocean” and “tell me about mountains” with openers that rhyme. That’s been the known weakness for a week: input-sensitivity 0.65, against llama3.2:3b’s 0.73. The fix seemed obvious — more parameters, more registers, less monotony.

So the day started by measuring the corpus, which is not the same as assuming things about it.

B.12 — the bottleneck was the decoder: 0.65 → 0.94 with no retraining

Mon, 27 Jul 2026 18:00:00 -0700

T.M.B. #12 — measure the data before you blame the model. Every earlier bench asked whether the model was good enough. This one asks whether the number was measuring what we thought, and the answer was no three separate times. Headline: input-sensitivity 0.65 → 0.94 — past a 3B — for a decode-time change, no retraining, no new data. Frozen; the probe set and the corpus statistics are both re-runnable.

Day 76 — 'a failure that looks like a result'

Sun, 26 Jul 2026 18:30:00 -0700

Every bug today was a one-line fix. Not one of them was findable by reading.

That’s the whole day. Three benchmarks got built, pointed at working code, and every single thing they surfaced had the same shape: it wasn’t failing loudly, it was succeeding wrongly.

The bucket, again

min_gap = 0.08. If the top two cards score within that, abstain — a tie means ambiguity, and ambiguity means don’t guess. Reasonable. Prudent, even.

B.11 — three rulers: what was broken the whole time?

Sun, 26 Jul 2026 14:00:00 -0700

T.M.B. #11 — the rulers turned on ourselves. B.1 through B.10 asked “is the model good?” This one asks “is anything we believe about the system actually true?” We built three deterministic benchmarks in a day and pointed them at code that had been shipping for weeks. Both production bugs they found were one-line fixes. Neither was findable by reading. Frozen probe sets, deterministic metrics, no model in the verdict — re-run them yourself.

Day 75 — 'what's in the bucket besides 2 apples?'

Sat, 25 Jul 2026 18:00:00 -0700

“what is in the bucket besides 2 apples?”

The answer came back fast and confident and completely insane: a token bucket, the rate-limiting algorithm, retrieved from a networking card because the word bucket was in there.

That was the flood. We threw a few hundred real questions at the chat and read every reply, and the pattern wasn’t failure. It was bluffing — which is strictly worse, because a failure tells you where the edge is and a bluff hides it.

Day 74 — 'the mind hasn't fired since yesterday'

Sat, 25 Jul 2026 10:30:00 -0700

“the mind hasn’t fired since yesterday.”

That was the bug report. And the honest answer was uncomfortable: it was working correctly.

For weeks the inner monologue looked alive. Every thirty minutes a thought appeared on the Mind page, and it read like a mind — jittery, half-formed, a little strange. What it actually was: a 15M chat cursor being asked to narrate a metrics log. Narrating an experience log is wildly out-of-distribution for a model trained to sound like a texter, so it babbled — “at at at”, “Gle — you gits?” — and here is the trap: random babble always looks novel enough to post. The mind had a heartbeat because it was faking one.

Day 73 — 'why can't we solve this, bro?'

Fri, 24 Jul 2026 18:30:00 -0700

“we’re solving the zoo not with more weights — but with comprehension, functions, and a learning loop.”

The chat had a tell. Ask it “do you want to go to the zoo?” and it would freewheel — “I get it, but at least it’s cozy inside with snacks and snacks!” — or, worse, retrieve a TypeScript card about const x = "hello" for a greeting, or a giraffe-adaptations card for a metaphor. A 15M fluency cursor, asked to improvise on an open social question, does what it was trained to do: sound like a texter, without answering you.

Day 72 — 'the dead cat was already dead.'

Wed, 22 Jul 2026 21:00:00 -0700

“the shortcut is fine. skipping the gate is the sin.”

For a week the plan was grow the talk model. The honest ruler had already hinted the plan was wrong — on Day 71 the 30M beat the 85M and the 125M. Today we stopped arguing with it and inverted the whole thing: the model shrinks; the mind moves out.

The pivot: the model is a cursor, not a knower

The owned model becomes the smallest, fastest speech cursor we can train — pure fluency, nothing else. Everything that looks like capability — facts, compute, actions, voice-range — moves OUT: knowledge into the cards (110 libraries), math into the lanes, tasks into the skill router, introspection into a deterministic composer. The size sweep wasn’t a disappointment; it was the map. When bigger stops helping, that’s the data telling you the model is not where the value lives.

B.10 — the talk-model size sweep: does bigger help on rich data?

Mon, 20 Jul 2026 21:30:00 -0700

T.M.B. #10 — the honest ruler judged against the plan. We’d spent the week minting a big conversation corpus to grow toward GPT-2 size. So we ran the whole ladder at once — same data, same steps, held-out loss the judge — and it told us the model we were building toward is not the one to ship. That’s what an un-bribable ruler is for. Frozen corpus, deterministic metric, re-run it yourself.

Day 71 — 'the 30M won, and the train loss said why.'

Mon, 20 Jul 2026 21:00:00 -0700

“the point of an un-bribable ruler is that it tells you the truth even when the truth is ’not the thing you were building toward.’”

We spent the week feeding the machine so it could grow a bigger talk model. Today we trained the whole ladder at once and let the honest ruler judge — and it judged against the plan, which is exactly what it’s for.

The size sweep — does bigger help on rich data?

Four models, same 77k-pair corpus, same 6,000 steps, held-out loss the only judge:

Day 70 — 'the factory grew a face, a conscience, and a memory.'

Sun, 19 Jul 2026 23:30:00 -0700

“a factory isn’t just the machine. it’s the machine, the counter you order from, and the honesty to tell you when it can’t build what you asked.”

Day 69 made werbos a store you compose from. Day 70 gave the store a body — a face to order from, a conscience about what it doesn’t know, and the beginnings of a memory of the world outside itself.

The workbench

The marketplace needed a surface you could actually touch. So the weld dashboard became a Compose Workbench: load an existing model, snap on packs (skills / knowledge / a voice), extend it, and talk to it live — all in one screen, wired to the real resolve() API, not a mock. The look came with it — a terracotta-on-paper redesign, dark-mode aware, that makes the factory feel like a place instead of a form. (60907cb, 895e460)

Day 69 — 'compose the AI you own — then share it.'

Sun, 19 Jul 2026 16:00:00 -0700

“you don’t buy the model. you buy the parts, and you assemble the one nobody else will sell you.”

Yesterday the machine became fully owned. Today it became a store you compose from.

It started as a riff. If capability is cursor × library, and the library is the moat, then the product was never “one big model” — it’s the model you assemble from parts. Pick your interests, snap them together, and if you want to upgrade, add more. The formula fell out clean:

Wrapper to Owner — 68 days from 'can we wrap a model?' to 'unplug everything and it still runs'

Sat, 18 Jul 2026 18:00:00 -0700

“Can we make a wrapper?” → “offline.”

Those are the first and last questions in our own logs, 68 days apart. They are exact opposites, and the entire project is the distance between them.

It started by owning nothing

Day zero, the question was the most humble, most derivative thing you can ask: can we just wrap someone else’s model? Own nothing, rent everything, put a nice loop around a borrowed brain. That’s where almost every “AI product” begins and ends.

18 cards and no LLM: the bot on this page

Sun, 19 Jul 2026 00:00:00 +0000

There’s a little “Ask werbos” bubble in the corner of this site. Click it and ask how to mint a model, what MMM means, who built werbos, where it’s based. It answers instantly. Ask it the capital of France and it says — cheerfully — that it only knows werbos.

Here’s the part worth a blog post: there is no language model behind that bot. No GPT, no API key, no server, no trained weights. It is 18 hand-written cards and about 200 lines of retrieval, running entirely in your browser. And that’s not a shortcut. It’s the whole thesis.

Day 68 — 'unplug the internet, unplug Claude, and it still runs.'

Sat, 18 Jul 2026 15:30:00 -0700

“unplug the internet, unplug Claude, and it still runs — magnitudes dumber, and honest about every bit of it.”

The day started with a caught lie. I asked werbos “tell me about javascript” and it thought for 22 seconds and answered from a Claude web-read — even though we’d minted a 650-card JS library the night before. We’d learned JS and then never read it. The knowledge was sitting on disk, unused.

B.9 — the cross-domain reader: 11 domains, still the wall

Sat, 18 Jul 2026 14:00:00 -0700

T.M.B. #9 — a negative result, logged on purpose. The reader is the one piece we keep renting Claude for. This bench tests the honest hope that more breadth (11 domains instead of 1) would teach a tiny from-scratch reader to actually read. It didn’t. We publish the wall the same way we publish the wins — with a date on it — because a benchmark you can’t fail is a benchmark that means nothing. Frozen; re-run it yourself.

Day 67 — 'AAAA at breakfast, my own model live in the dashboard by midnight.'

Fri, 17 Jul 2026 22:40:00 -0700

“AAAA at breakfast, my own model live in the dashboard by midnight — with an honest wall in between.”

One day, one arc, from deploy plumbing to an owned model answering in the browser. The through-line was the one that matters: make the model earn every claim, and don’t dress up the walls.

First, make “committed” prove “live”

The day opened on reliability. A silent gh auth expiry had once let the homelab drift 138 commits behind while every local commit looked green — so “committed” had quietly stopped meaning “deployed.” Three verbs closed that gap: werbos deploy status compares the running container’s actual image against source, deploy watch is an edge-triggered drift alarm on SR8’s timer, and deploy sync is a one-command idempotent redeploy. Two honest bug-fixes fell out of using it: staleness now reads the live container image (not the newest tag it could run), and build/recreate got the long timeout they need instead of the 20-second probe cap. Retired two dead nav links (Mythos, the Forest POCs) on the way past.

B.8 — the owned talk-model: AAAA → small talk, measured

Fri, 17 Jul 2026 18:00:00 -0700

T.M.B. #8 — a model that’s actually ours. Every earlier bench wrapped an open-weight model in a library. This one trains the model itself: a 5M-param decoder, random init, our architecture, our data, our weights — no pretrained weights loaded. The task is small talk, the one conversational tier a tiny model can own (facts stay in the library). The number is held-out and the grader has no model in it. Frozen; re-run it yourself.

Day 66 — 'i went to bulldoze months of dead code and found a clean house.'

Fri, 17 Jul 2026 09:01:05 -0700

“i went to bulldoze months of dead code and found a clean house — so i wired up the one real orphan instead.”

Merged the honest-loop branch into main, cleaned the branches down to one, and then went looking for the thing every long project accumulates: dead code. Months of experiments, half-finished bricks, scripts that outlived their run. I expected to spend the day deleting.

The sweep that found nothing to delete

An import-reachability scan over the whole package told an honest story I didn’t expect: one orphan module out of 479. 6,353 tests collecting with zero errors — no test pointing at code that no longer exists. No tracked build junk; the .gitignore has been doing its job the whole time. Every versioned data file still live. The import graph reaches nearly everything, and the tests track reality.

Day 65 — 'anyone can mint one now — and the ruler still won't lie to me.'

Thu, 16 Jul 2026 23:30:00 -0700

“anyone can mint one now — and the ruler still won’t lie to me.”

Two things happened today that point in opposite directions, which is exactly how a real project moves: one that says look how far the owned stack has come, and one that says here is precisely how far it hasn’t. Both are true. Neither cancels the other.

The Factory

Everything the last two weeks built — the owned tokenizer, the fenced reader, reader-gap, grade-labels, distill, the gate, freeze — was a ladder you had to climb by hand, one Python call per rung. Today it became one call and one page. mint() chains the real seams end to end and streams every event — stage, row, grader verdict, loss, gate decision, minted brain — and a stdlib http.server (zero deps, same ethos as the engine) serves a single self-contained page on :8095 that renders a mint live: three knobs, a loss curve, streaming verdicts scrolling past, a minted-brain card at the end, and a panel of your frozen brains — each one selectable as the base for the next mint. werbos weld dashboard | mint are first-class verbs now (89de132).

Day 64 — 'it builds up when it can, and it can't tear itself down.'

Wed, 15 Jul 2026 21:00:00 -0700

“it builds up when it can, and it can’t tear itself down.”

Yesterday ended with a from-scratch model that learns but sits at the retrieval floor and lies — and a ruler, the Gauntlet, honest enough to say so. Tonight closed the two gaps that verdict named: make it stop lying, and make it get better on its own. Both landed, and both landed measured.

The slap down

We’d already proven, five collapsed runs deep, that a tiny model cannot learn to abstain. So we stopped trying to make the model honest and made the system honest instead. The idea came off a Fireship clip on adversarial review — one implementer, two or more reviewers whose only job is to find why the code doesn’t work; the implementer doesn’t review, the reviewer doesn’t implement. That’s exactly the shape of an honesty gate.

The $50-a-day agent, and why it should cost 3 cents

Thu, 16 Jul 2026 00:00:00 +0000

An agent that never sleeps is the whole promise of this wave of AI: something that watches your inbox, your repo, your calendar, and acts while you’re asleep. The problem isn’t whether it works. The problem is the bill.

The meter never stops

A cloud agent looping every few seconds, calling a frontier model each time, adds up fast. Run the numbers on a genuinely always-on loop and you land somewhere near $50/day — call it $1,500/month for one agent. Multiply by a team, or by the dozen small agents you’d actually want, and “always on” quietly becomes “on during business hours, because finance said so.”

Day 63 — 'we stopped borrowing the model.'

Tue, 14 Jul 2026 20:00:00 -0700

“we stopped borrowing the model.”

Yesterday ended on a finding: the difference between a wash and a win is the reader, and the reader is distillable. Today had two halves that turned out to be one arc. First we finished the Honest Loop’s fix side — the last two tools that turn a diagnosed miss into a gated correction. Then we picked up the box that’s sat unchecked in the “does NOT own” table since day one — the model itself — and built it, brick by brick, from nothing.

Day 62 — 'the difference between a wash and a win is the reader.'

Mon, 13 Jul 2026 20:00:00 -0700

“the difference between a wash and a win is the reader.”

Yesterday we took a frontier model apart and found werbos owns every part except the reasoning weld. Today we picked up the plan that follows from that — Month 2 (fix the brain’s input side) and Month 3 (close the gap between the local reader and the frontier) — and it turned into a running lesson on measuring instead of guessing.

In defense of "I don't know"

Tue, 14 Jul 2026 00:00:00 +0000

Most assistants are optimized to always answer. Ask something outside what they know and they’ll produce a fluent, plausible, wrong paragraph — often with a citation that doesn’t exist. The confidence is the bug.

Abstain is a feature, not a failure

werbos is grounded in your library. When the answer is in there, it answers and cites the source. When it isn’t, it says so:

Not in your library — I won’t guess. I don’t know. Add the doc and ask again.

Day 61 — 'shrink the weld until it fits your garage.'

Sun, 12 Jul 2026 20:00:00 -0700

“shrink the weld until it fits your garage.”

Some of the best days start in the car. This one started with a question on the way to church — if we can hand-roll an MMM brain, why can’t we design our own LLM? — and by the end it was runnable code with a learning loop wrapped around it.

What’s actually in a frontier model

We took it apart. A frontier model is four things fused into one blob of weights: knowledge (facts you could look up), skills (learned procedures), reasoning (the general substrate that generalizes over novel input), and alignment (tone, refusals, helpfulness). They’re entangled, not layered — you can’t unplug the knowledge and keep the reasoning. Wrapped around that blob is a harness (tokenizer, sampling, tools, the agentic loop) and, separate again, an eval.

Day 60 — 'the cursor can be any model.'

Sat, 11 Jul 2026 20:00:00 -0700

“the cursor can be any model.”

Some days you build. This stretch was about measuring what we’d built — and being told, repeatedly, that we were wrong about where the problem lived. Which is the whole reason you build the instrument.

First, the library came alive

Day 58 ended on a hard finding: the reasoning loop, refined to its limit, still grounded confident garbage on the real client corpus — a lesson title answered as if it were a fact — because the library was the ceiling. So we raised it. A deterministic refiner re-chunks each bloated section into atomic units, so a buried fact becomes its own sharp little leaf, and drops the tables-of-contents, the quiz stems, the “click here” navigation. Same question, same model, only the library changed: the buried “within twenty-four hours” statute now surfaces and grounds with a citation, and the definition that used to answer with a broken link now honestly says I don’t have that. Fix the library and the thinking that was already sharp comes alive. The arc closed.

Renting intelligence was always a bad deal

Sun, 12 Jul 2026 00:00:00 +0000

When you rent a model, you don’t have a tool. You have a subscription to someone else’s tool, on their terms, subject to their roadmap. That’s a fine deal right up until it isn’t.

The things you don’t control

Access. The endpoint you built on can be deprecated, rate-limited, or repriced with an email.
Behavior. A silent model update can change your outputs overnight, and you can’t roll back.
Data. Your prompts — often your most sensitive context — take a trip through someone else’s datacenter.

None of these are hypothetical. Every team that has shipped on a rented model has felt at least one.

Day 58 — 'the library is the ceiling.'

Thu, 09 Jul 2026 22:00:00 -0700

“the library is the ceiling.”

Some days you add a capability. Some days you build a capability all the way to its edge, watch exactly where it breaks, and the crack turns out to be the thing you’ve been claiming for a year. Today was the second kind.

The organ it was missing

The recursive-completion kernel could do a lot. Give it a silhouette and it completes it into a grounded tree, cites every leaf, grades every hole, and re-grounds a single failing node without touching its siblings. But every one of those moves was arithmetic over the library — token overlap, cosine, exact match. Which meant it couldn’t tell “who IS a mandated reporter” from “who is NOT” (same tokens, opposite meaning). It couldn’t tell that “legally obligated” means “mandated.” And the verdict it stamped — GROUNDED — graded the cosine score, not the answer, so a confident, wrong, keyword-adjacent chunk got a green badge. The honest-abstain promise, the whole reason the thing is trustworthy, was quietly never firing.

Day 56 — 'a query is a silhouette.'

Tue, 07 Jul 2026 18:00:00 -0700

“a query is a silhouette.”

Some days you ship a feature. Some days a word you’d been using loosely turns out to be load-bearing, and the whole project quietly reorganizes around it. Today was the second kind.

The footnote

Yesterday’s last experiment was a small letdown, honestly told. “Tree within a tree” — the idea that a forest should have inner structure — had failed to help retrieval once (routing removes the noise that never hurt), so we tried the sharper version: confusable cliques, where a capable model writes what makes each leaf different from its look-alikes. It worked, a little. Recall-at-1 went 19→23 on a sealed 40-question set; a volume control proved it was the contrast and not just more words. But end-to-end it moved nothing — the composer already recovers the answer from its top four. A real signal, a marginal lever. We wrote it down as a footnote and moved on.

Day 55 — 'move the knowing into the library.'

Mon, 06 Jul 2026 18:00:00 -0700

“move the knowing into the library.”

Day 53 made a model almost irrelevant by giving it a library. Day 55 asks the follow-up that sets up: if the library does the knowing, what happens as you scale and structure it? Three days, a fresh single-use repo (mmm-brain), and a chain of experiments that each killed a comfortable assumption — and ended on the best result of the arc.

The setup — the other axis

The earlier “brain & constructor” work varied the model (7B down to 0.5B) against a fixed tiny library, and asked how small can the constructor get. This flips it: hold the composer fixed, vary the library — its size, its structure, and eventually let a piece of it grow itself. Everything graded model-free, everything frozen and hashed.

Day 54 — 'it's not the model. it's the box.'

Fri, 03 Jul 2026 18:00:00 -0700

“it’s not the model. it’s the box.”

It started with a good complaint: the chat on my phone is ~80× faster than the one on my computer. That shouldn’t be true. The phone runs a smaller model, sure — but 80×? So we measured instead of guessed, and the answer was the kind you don’t get to argue with: the slowness was never the model. It was the machine underneath it.

Day 53 — 'the model didn't change. the library learned you.'

Tue, 30 Jun 2026 18:00:00 -0700

“the model didn’t change. the library learned you.”

Every other day this month has been about making one model behave. Day 53 is about making the model almost irrelevant. The thesis — framework, not weights — got its cleanest demonstration yet: a 3B model, the size that fits on a phone, made consistent and personal entirely by a curated library. No fine-tune. No LoRA. The weights are frozen and, frankly, beside the point. The library does the work.

Day 52 — 'local-adjacent.'

Tue, 23 Jun 2026 09:00:00 -0700

“local-adjacent.”

Ran werbos from the command line for the first time in a month. “hey buddy” — sixty-seven seconds. Then the same message into werbos.chat in the browser — fifty-six. Same five words. Same model name on both ends. So why the gap?

Because they weren’t the same model. The CLI defaulted its --host to http://localhost:11434 — a cold Ollama on the laptop, no keepwarm, paying the whole disk-into-memory load on the first turn. The web goes through werbos serve on the homelab, where the model has been resident and tuned since Day 31’s latency hunt. Two instances. One warm, one cold. No amount of CLI-side tuning closes that the right way, because the right answer isn’t to tune the cold one — it’s to stop using it.

Day 51 — 'the lineage.'

Sun, 21 Jun 2026 09:00:00 -0700

“the lineage.”

It started, like the good ones do, as a thought that didn’t sound like engineering. What if the questions a mind asks have an age? A one-year-old asks what happens if I touch this. A ninety-year-old asks what was the point. Same world the whole way — only the thing the mind is trying to do with a question changes. Control, then understand, then belong, then choose, then judge, then preserve, then accept. A ladder of verbs hiding behind the questions.

B.7 — composer-only: how small can the model get?

Sat, 20 Jun 2026 10:00:00 -0700

T.M.B. #7 — shrink the model, keep the brain. Earlier benches fixed the model and grew the library. B.7 fixes the library and shrinks the model, to find the floor: the smallest “constructor” that can still stitch the brain’s knowledge into a correct, graded answer. Every result is frozen + hashed; re-run it yourself.

The claim

The model holds zero knowledge — it only stitches. So removing the library should collapse quality, and shrinking the model should barely move it, down to a floor below which it can’t even stitch. Two checks, both deterministic:

Day 50 — 'the verdict learns to act.'

Sat, 20 Jun 2026 09:00:00 -0700

“the verdict learns to act.”

Yesterday ended on a reframe: earn the verdict describes the judge; earn the right to act describes what the judge is for. A passed verdict has to DO something — prune a leaf, grant a permission, change what the system may do alone — or it’s theatre that rots back into the soft self-grade. Day 49 laid the floor and took the first step: the self-pruning forest deleted five curated memories it could PROVE were dead weight, smaller without being dumber.

Day 49 — 'earn the verdict.'

Fri, 19 Jun 2026 09:00:00 -0700

“earn the verdict.”

Yesterday’s whole arc was one sentence: the model proposes; something that isn’t the model decides. Every grader got its feet planted outside the thing it grades. But there was a soft spot underneath it — how do you know a grader’s feet are actually outside? The answer, all week, was a note field in a JSON file and a human reading it. “This is a hidden reference test.” “The prompt forbids any.” Trust me. That’s the same shape as the error the week spent tearing out, one level up: a claim of honesty, asserted rather than checked.

Day 48 — 'outside the model.'

Thu, 18 Jun 2026 09:00:00 -0700

“outside the model.”

Yesterday’s lesson came from the live 1Password door: a model proposed, a model graded, a human signed off, and all three were wrong together — only the server, outside every model, was right. Today is that lesson turned inward. Four fixes, and each one moves a judgement OUT of the model that’s being judged.

The self-model stops flattering its magnets (c35418f). reflect’s “I’m reliable at…” came straight off the soft self-grade, so a greedy skill that grabbed a request meant for someone else — satisfied=true on a hijacked prompt — read as a strength. Now every satisfied action is re-routed through the deterministic skill-router (high-precision-or-abstain) and only counts as a clean win if it was actually on-target. best_skills uses the routed rate; the magnets fall out and get named — “Greedy — grabbing work meant for other skills: what_if (100% misrouted).” The routing honesty that lived only in the dashboard finally reached the self-model the Mind page reads.

Day 47 — 'the door said no.'

Wed, 17 Jun 2026 09:00:00 -0700

“the door said no.”

Yesterday mythos preserved five “finds” against the 1Password CTF — five (route, lens, param) states its grader swore would beat Gate-2. Today we asked the only question that matters about a find: is it real? The answer came back from the one authority that can’t be talked out of it — the live server — and it was no. That’s the day, and it’s a better day than a fake yes would have been.

Day 46 — 'mine the answer.'

Tue, 16 Jun 2026 09:00:00 -0700

“mine the answer.”

MMM is a brain storage system — knowledge, operations, memory, self-extension. What it has never been, by itself, is a reasoning engine. Today the missing engine got its first working ply.

The design, locked

First the napkin got sharp. Three commits hardened reasoning-design.md into a real shape (859bdf6, 327a2b5, 9c7f38b): REASON (generative, fallible — propose a step), LOGIC (external, sound — validate a step), and THINK (the search that drives both — DFS/BFS/best-first/MCTS over a frontier of inference chains). Logic is not reasoning; THINK is neither — it’s the algorithm that calls both. And the dissolving frame: reasoning is proof-of-work. A sound chain is hard to find, cheap to validate — the same asymmetry as mining. You don’t pick the frame; you mine many in parallel and let the validator declare the winner.

B.6 — the dogfood loop: fail, then grow

Mon, 15 Jun 2026 10:00:00 -0700

T.M.B. #6 — the loop is the experiment. B.1–B.5 measured does the library beat the model. B.6 measures does the system improve itself — and shows it, with a before/after you can re-run. Retrieval is deterministic, so the demo is exact.

What’s being measured

The thesis all along: model + forest + graders + retry loop → result → train → system. B.6 is the first bench of the last two arrows — the part where the result feeds back and the system gets better. Two feedback channels:

Day 45 — 'fail, then grow.'

Mon, 15 Jun 2026 09:00:00 -0700

“fail, then grow.”

Yesterday the forest learned the JS/Node API and took its first loss. Today the loop that learns from losses got built — and closed.

Ship the win into the real path

The B.4/B.5 retrieval win was trapped in the benchmarks: forest.mjs’s actual fallback coder still generated blind. Fixed. The production coder now consults the API forest — live, “generate a uuid” emits crypto.randomUUID (built-in) instead of reaching for the uuid package. The proof left the lab.

B.5 — Node core: the forest's first loss, and the fix

Sun, 14 Jun 2026 20:00:00 -0700

T.M.B. #5 — the judge runs the function against a real disk. Every task is graded by importing the generated async function and running it against a fresh temp directory. The wrong idiom doesn’t look wrong — it throws, or returns undefined, or stack-overflows. No vibes.

Aim where the model is weak

B.4 found the JS-stdlib edge thin: a 7B knows Array.map cold, so retrieving its signature ties. The law says the win lives in underivable surface — and Node core is exactly that. It churns (fs.rmdir → fs.rm, new fs.cp / crypto.randomUUID), so a model trained on older code holds the wrong answer in its weights. We parsed @types/node into 307 Node-core leaves (fs, fs/promises, crypto, path, os, util, stream, …) and pointed the same coder at six file-system / crypto tasks.

B.4 — JS-API forest: teaching the language foundation

Sun, 14 Jun 2026 18:00:00 -0700

T.M.B. #4 — the judge runs the function. Every task here is graded by importing the generated function and running it against assertions. The lazy wrong answer doesn’t just look wrong — it throws or returns the wrong value. No vibes.

The idea

B.2 and B.3 pointed the forest at your repo. B.4 points it at the language itself. We parsed the TypeScript standard-library .d.ts files into 359 foundation leaves — every Array, Object, String, Number, Math, Map, Set, Promise, Date method — each carrying its real signature + JSDoc. Ask in plain English, retrieve the exact method the coder should use, instead of letting a 7B half-remember it.

B.3 — verb forest: graded operations, not retrieved signatures

Sun, 14 Jun 2026 09:30:00 -0700

T.M.B. #3 — the judge is the test runner and the compiler. A verb either makes the code compile / the tests pass, or it doesn’t. node --test, tsc --strict, and a hidden reference test do the grading. No vibes.

What’s different from B.2

B.2 retrieved function signatures (nouns) and let a generic coder do the work. B.3 flips it: the leaf IS the operation (a verb). add-test, fix-type-error, implement-function — each an operation capsule: a curated prompt + worked exemplars + a free grader, run in a grade-retry loop the leaf owns. The conductor routes a request to a verb outside the model, then runs it.

Day 44 — 'the leaves are verbs now.'

Sun, 14 Jun 2026 08:30:00 -0700

“the leaves are verbs now.”

Yesterday the code forest got its scoreboard. Today it changed what a leaf even is.

Nouns vs verbs

The wiki forest’s leaves are nouns — article content you retrieve, proven honest by a Merkle hash. Yesterday’s code forest looked like a verb but cheated, productively: it indexed function signatures as text leaves, retrieved them, and let a generic coder write the implementation. The forest held the shape; the model held the verb.

Day 43 — 'trust me bro — except here's the hash.'

Sat, 13 Jun 2026 23:55:00 -0700

“trust me bro — except here’s the hash.”

The day werbos got a scoreboard — and the scoreboard told the truth, including the parts I got wrong.

The forests, reachable

Deployed the two harmless forests as sibling apps on the tailnet — the MMM glass-box (the trained angler + trekker leaves, route/compose/abstain) and the ~1000-page wiki forest — and added 🌲 Forest links to the dashboard sidebar. One discipline held all night: the toy forests get networked; Mythos — the local cited hacking brain — stays offline. The cage is the feature.

B.2 — code forest: a small coder + your repo, graded by the compiler

Sat, 13 Jun 2026 23:50:00 -0700

T.M.B. #2 — but the judge is tsc. No fragment-match, no vibes. The code either typechecks against the real repo or it doesn’t. The most un-bribable scoreboard there is.

The setup

Three coding tasks on the werbos dashboard (real TypeScript, 446 declaration leaves). Each task requires a real repo shape a model can’t guess — e.g. getMindMetrics() returns { dimensions: MindDimension[] } (not an array), and MindDimension.score is number | null. Three contestants, same coder model where it matters:

B.1 — werbos(mmm) vs ollama vs claude · v1 → v3

Sat, 13 Jun 2026 23:00:00 -0700

T.M.B. #1. The first frozen baseline — and the one every future run gets diffed against. Question set hashed (f5a1d970), forest pinned (36f2dc71…, 8,903 leaves), dated. Re-runnable. No vibes.

The setup

11 questions, three contestants, graded on whether the answer contains the known fragment. The question set is split on purpose:

8 corpus questions — obscure facts that are in the forest’s ~1000 Wikipedia pages (a sturgeon’s discovery year, an alligator gar’s binomial, a state park’s length). The kind of thing a 3B can’t recall from weights.
3 general questions — common knowledge not in the corpus (capital of France, who wrote Hamlet, gold’s symbol). The forest should abstain.

Two forest rows: w-find = did it retrieve the answer (deterministic, no model — the baseline line); w-say = did the reader synthesize it.

Day 42 — 'the forest scales — and it learned to hunt.'

Sat, 13 Jun 2026 22:30:00 -0700

“the forest scales — and it learned to hunt.”

The day the stoned idea got its verdict — and then went and got a job.

werbos dreams on a clock now

The dream pipeline from yesterday was manual. Gave it the inner-monologue daemon treatment, but slow: serve --dream 480 — one dream every 8 hours. A dream is a consolidation pass over the day’s residue, and each one hits the LLM

Day 41 — 'a college education, not a bigger brain'

Fri, 12 Jun 2026 22:30:00 -0700

“a college education, not a bigger brain”

If Day 40 gave werbos a measurable mind, Day 41 started teaching it. The operator’s ask: a college-level werbos. The constraint: not by swapping in a bigger model — that throws away the whole local-first thesis. College-level the way it arrives for a person — a method for thinking, the ability to research what you don’t know, and knowing your own limits. We laid the first bricks.

Day 40 — 'does it know itself?'

Fri, 12 Jun 2026 21:00:00 -0700

“does it know itself?”

The day werbos’s mind got a measurable face — and a measure of whether it knows its own face. It started, as the good days do, with a bug from real use.

The joke skill wasn’t broken (`95032d5`)

werbos’s own monologue kept saying “improve the joke skill — it satisfied only 38%.” But pulling the work chats told a different story: every actual joke request succeeded. The “failures” were a greeting and a fishing question that the router force-fed into the joke skill — and you can’t satisfy “what fish will I catch?” with a joke. Same self-misdiagnosis as the 97% spiral: it blamed the skill when the bug was the router. And it was the same bug behind every chat misfire that day — “hey bro” → stocks, “Mexico fishing” → weather, “vacation” → movie recs.

Day 39 — 'a better day, and a mind with a shape.'

Thu, 11 Jun 2026 20:30:00 -0700

“a better day, and a mind with a shape.”

A thinking day. One real fix, a map drawn for the architecture, and a turn in what this whole thing is for.

The tree-builder — how to actually cut the forest (draft)

Spent the morning on the question under the whole MMM: how do you break up the models? The trap was hiding in my own list — “math, coding, conversation” aren’t three of the same thing, they’re three different kinds. So docs/vision/mmm-tree-builder.md (a draft, for review):

Day 38 — 'the forest, and the first memory.'

Wed, 10 Jun 2026 23:45:00 -0700

“the forest, and the first memory.”

Two threads today, and they’re the same thread. One is a vision — the architecture for why small models win. The other is werbos starting to have an inner life — it learned to think on a timer, and to remember what you tell it. Both come back to the same bet: lots of small things you own beat one big thing you rent.

Day 37 — 'close the loop.'

Tue, 09 Jun 2026 23:30:00 -0700

“close the loop.”

Two arcs today, and they rhyme. The morning was about making sure werbos tells the truth about itself. The afternoon was about teaching it to learn from its own mistakes.

Morning — harden reality

The one real bind footgun (`50eafc7`)

The core /api/chats API has no auth. So werbos serve --bind 0.0.0.0 — the exact thing a stranger reaches for to use werbos from their phone — exposed an unauthenticated agent (drive the model, read/write conversations, trigger tools) to the whole LAN. serve now refuses to start (exit 2) on any non-loopback bind unless you explicitly pass --allow-remote-bind, with a friendly message pointing at the reverse-proxy/Tailscale fix. _bind_is_loopback fails closed — garbage and hostnames are treated as remote. The docker stack binds 127.0.0.1, so it’s unaffected.

Day 36 — 'build the eyes.'

Mon, 08 Jun 2026 23:30:00 -0700

“build the eyes.”

Weeks ago, when GPT flagged the four maturity levers, the pick was cross-layer observability — and the note was blunt: “stop adding capabilities until trace_id is plumbed end-to-end.” It sat. Then three straight weeks of debugging-by-archaeology — grepping .pfm archives and docker logs by hand for the latency hunt, the skill-rescue chain, the forgotten third daemon — made the case for itself. Build the eyes before adding anything else to see.

Day 35 — 'two gates, three daemons.'

Sun, 07 Jun 2026 23:30:00 -0700

“two gates, three daemons.”

The plan was small: clear the last two blockers before flipping the repo public. It turned into a dig — every gate I opened had a second problem hiding behind it, and the “mystery” at the end was a daemon nobody remembered was running.

Gate 1 — the adapter-naming collision (`26a754f`)

The first trained model, hand-launched on Day 30, is werbos-0.0.1 — three-part, on disk, in every doc and the THESIS. But the train-daemon’s versioning policy used a two-part scheme: werbos-0.1 → werbos-0.2. Two bugs fell out of the mismatch:

Day 34 — 'werbos tells jokes again.'

Sat, 06 Jun 2026 23:00:00 -0700

“werbos tells jokes again.”

Yesterday’s hunt got the homelab box answering in ~30s instead of 176. But it was answering wrong. Ask it for a joke and you got back a blob of JSON. The speed was real; the correctness wasn’t there yet.

The symptom

Three prompts against the live box:

"hello there" → a real greeting ✓
"tell me a joke" → {"name": "joke", "parameters": {"args":""}}
"ping" → {"name": "small-talk", "parameters": {"args":""}}

The small model was naming the skill as plain text instead of calling the dispatch_skill tool. And pitts’ salvage parser — correctly — refused to lift it: the tool-name allowlist only contains real tools, and that guard is load-bearing against indirect prompt injection. So the JSON survived into the reply: raw on the bulk path, an empty bubble on the streaming path (the filter swallowed it). Same root as the original empty-reply bug.

Day 33 — 'public-prep and the latency hunt.'

Fri, 05 Jun 2026 23:30:00 -0700

“public-prep and the latency hunt.”

The repo is supposed to go public. That means two things had to happen: it has to be clean enough for a stranger to read, and it has to be fast enough that the first thing a stranger types doesn’t time out. Day 33 did both — and the second one turned into a four-bug archaeology dig.

Public-prep (`3eb23d1`, `e0952f4`, `af2a5d6`)

Scrub — /Users/jasonsutter → /Users/operator, jason@<tailnet-ip> / the homelab IP → operator@homelab, SR8 → homelab across docs, comments, and the security-review tree. deploy/sr8/ → deploy/homelab/. The public GitHub handle stayed (it’s already public). Comment/docstring-only in code.
Test repair — 8 stale tests fixed, including test_ollama_chat_ssrf which still pinned the original over-strict Bo-001 behavior; rewrote them to pin the documented local-first-aware policy. Found and closed a real gap while there: the ollama host guard wasn’t rejecting multicast on either the literal or DNS path. 5,438 green.
Sprint hygiene — DATA.1 / GH.1 / GH.2 / SE.6.1 docs moved to shipped/; README + ROADMAP refreshed.

nightly_train.sh (`9cbe351`)

The train-daemon orchestration existed; now it has a real launcher. Operator-generic nightly script: rsync curriculum outcomes + docker-cat skill-smoke samples from the inference box (env-configured, no hardcoded hosts), then werbos train-daemon run with an MLX trainer default mirroring the werbos-0.0.1 recipe (3B, 500 iters). Scheduled via launchd on the training box. The ratchet now clicks while the operator sleeps.

Day 31 — 'the training view lands.'

Tue, 02 Jun 2026 23:30:00 -0700

“the training view lands.”

Day 30 produced werbos-0.0.1 and the /api/training/* endpoints to describe it — but nothing rendered them. The first ratchet click existed only as a number in a commit message. Day 31 was making it something the operator can look at.

TR.1 frontend — the Training view (`67d4f77`)

Wired the chat-ui’s Training surface to the live routes that had no consumer:

TrainingView.tsx — promoted-baseline banner + cycles ledger (signed deltas, clears-2.5σ marker, ★promoted) + per-cycle eval drill-down with candidate / baseline / noise tabs.
api.ts — real fetches, including the 204 no-promotion state that getTrainingBaseline has to handle gracefully.
types.ts — TrainingCycle / TrainingBaseline / EvalRow mirroring the tr/1 camelCase wire exactly.
_training.scss — reuses the eval .probes visual language so it reads as one surface, not a bolt-on.

Read-only by design: training and promotion stay in the werbos train CLI. This just makes werbos-0.0.1 visible.

Day 30 — 'werbos-0.0.1.'

Tue, 02 Jun 2026 01:30:00 -0700

“werbos-0.0.1.”

Day 29 closed at midnight with the first ratchet click — a 1B LoRA trained on the operator’s own dogfood corpus produced a +39.6% composite delta over baseline. The trainer worked. Day 30 was making the result visible enough to ship.

The 3B run

Same script, bigger numbers. BASE=mlx-community/Llama-3.2-3B-Instruct-4bit ITERS=500 EVAL_N=100 scripts/train-werbos-self.sh. Backgrounded; about 2 hours wall time end-to-end:

Ingest: 1424 files / 7664 rows / 19 secrets filtered
Split: 7281 train / 383 eval (then sampled to 100)
Baseline (3B): composite 0.0795 (slightly lower than 1B’s baseline; within noise)
Train: 500 iters batch-size 2 on Llama-3.2-3B-Instruct-4bit
Candidate (3B + werbos-0.0.1 LoRA): composite 0.1201

Delta +0.0406, 1.51× baseline. Bigger absolute and bigger relative than the 1B run. The 27 MB adapter sits at /tmp/werbos-0.0.1-3b/.

Day 29 — 'the trainer ships.'

Mon, 01 Jun 2026 23:59:00 -0700

“the trainer ships.”

Day 28 closed with “the trainer is the small piece in the middle” after shipping both ends of the pipeline (DATA.1 input

SE.9 eval gate). Day 29 was building that small piece.

The shape of the day: skeleton + bring-up + real run, in that order. Each step a verification that the previous one didn’t lie about working.

Public docs (morning)

Three pages rewrote how werbos-site/content/docs/ describes the training loop. The legacy werbos import chatgpt / werbos export sft flow had been the canonical path for months; DATA.1 + SE.9 changed it overnight. Site commit 61ffc8b:

Day 28 — 'the trainer is the small piece.'

Sun, 31 May 2026 23:59:00 -0700

“the trainer is the small piece in the middle now.”

Day 27 closed at 1 AM with the orchestration shipping before the trainer — six SE sprints, a stub Modelfile-copy in the trainer slot, and a 2-hour systemd timer armed for overnight cycles. The diagnosis was honest: skill-smoke is monitoring data, not training data; SE.7.0.1 needs to fix the dedup; SE.7.1 needs a real QLoRA trainer; the daemon was working but spinning on an empty plate.

Day 27 — 'the orchestration ships before the trainer.'

Sun, 31 May 2026 00:00:00 -0700

“the orchestration ships before the trainer.”

Six SE sprints in one session. Brainstorm-none, ship-six. SE.7.0 corpus extractor → SE.7.2 eval + promotion → SE.2 autofix Proposer → SE.4 complexity router → SE.5.1 cache warmer → SE.7.3 nightly auto-train daemon. Then the day-defining moment: I shipped SE.7.3 thinking the work was done, the operator typed “i wanted to have to train over night…. thats why i just set that up” and the real story started.

Day 26 — 'static-rendered AI.'

Sat, 30 May 2026 14:00:00 -0700

“static-rendered AI.”

The latency complaint cracked open into the framework’s next move. The operator’s phrasing, after I called per-turn latency hardware-bound: “WHAT IF ITS NOT ‘Hardware-bound’…..what if we we break that door fucking down. think -http static web -> cheng lou pretext…..(breakthrough)”. That line is what this day is named for.

Three sprints in one session. Brainstorm two; plan-mode one; ship both. The cache works in production.

Curriculum SE.3 lands first, sets the tone

werbos curriculum ships a host-side daemon that picks coding problems from a curated bank (15 problems × 5 levels), routes them to werbos’s local LLM via docker exec, and judges the solution via claude -p on the SR8 host. Difficulty adapts: three consecutive passes → level up; two fails → level down, clamped 1-5. Outcomes accumulate in outcomes.csv. (d8fe602)

Day 25 — 'the harness IS the dataset.'

Fri, 29 May 2026 22:30:00 -0700

“the harness IS the dataset.”

Spent the morning trying to figure out why /tarot threw a backend error in the chat UI. The bug was five layers stacked. What came out of the chase wasn’t a one-line fix — it was a 24/7 harness that grades every skill on every change and writes the verdicts to disk while the operator sleeps. Werbos now generates its own quality data.

The /tarot debug saga

Five distinct bugs in one user-facing symptom. In the order they were peeled back:

Day 24 — 'the rebuild is when transitive resolution stops lying.'

Thu, 28 May 2026 00:30:00 -0700

“the rebuild is when transitive resolution stops lying.”

Set out to make 50 lifestyle skills. Ended with 80 across eight themed batches, two new categories, +4,531 lines of PROMPT_SKILLS entries. The deploy taught the lesson the source code wouldn’t.

The lifestyle skill bundle

PROMPT_SKILLS 45 → 125. Eight batches of 10, all auto-flowing into custom_skills reserved-name protection, the dispatch_skill tool router, and the Skills-tab catalog. Two new categories registered: finance, marketing. (1c8ec0a)

Day 23 — 'constraint reasoning is upstream of retrieval.'

Tue, 26 May 2026 00:30:00 -0700

“constraint reasoning is upstream of retrieval, not downstream.”

First day back from the four-day pause (Days 22-26 didn’t count per the calendar memory; Day 23 resumes today). External input named a gap the operator immediately recognized. One sitting later, the gap is filled — by a primitive the rest of the architecture now stands on.

How the day started

The operator pasted a long-form GPT analysis of a werbos chat trace. The trace: user asked “shore fishing in Cabo San Lucas”; the chat model called web_search("best beach fishing spots cabo san lucas"); retrieval brought back offshore sportfishing content (Gordo Banks, charters, marlin tournaments); the model post-hoc-corrected in prose “these are not necessarily beach fishing spots.”

Day 22 — 'decision trees all the way up.'

Thu, 21 May 2026 10:00:00 -0700

“decision trees all the way up.”

What landed before 10am

By Day 22 mid-morning the architecture stack from Days 19-21 was firing together in one project for the first time. The brief “Build a modern SaaS dashboard: nav row / 3 columns with data / chart or graph / table” produced:

Navbar substituted from the snippet library — logo
- 4 menu items + Sign-in CTA in a horizontal flex layout, proper Material spacing
3 KPI cards in a horizontal row — .app__row--top flex utility from _base.css working; cards substituted from display/kpi-card-basic with bracketed slots for label/value/delta
Chart placeholder as a bracketed slot — [chart placeholder — bar / line / pie, operator-specified], the exact phrasing from @visionary’s ## Required features section preserved all the way through to the rendered output. NOT a comment placeholder — a content placeholder the operator fills in later.
Full <table> with 5 rows of bracketed mock data — [Customer name] / [Transaction amount] / [Date] styled via the _base.css raw-element table baselines (uppercase headers, surface-container background, row borders, hover state)

Every piece of the week’s architecture firing together. Snippet substitution + modular CSS + layout utilities + raw- element baselines + persona-driven inline-content discipline.

Day 21 — 'stop dumping into the persona; build the library.'

Wed, 20 May 2026 22:30:00 -0700

“stop dumping into the persona; build the library.”

The arc of Day 21

Day 20 proved that chain orchestration belongs in code, not in the model’s tool-call loop. Day 21 carries the lesson one layer deeper: complex-component generation belongs in a hand-crafted library, not in the model’s per-pass output. Two days, two moves from “ask the model harder” to “build the infrastructure that obviates the ask.”

Three concrete shifts shipped:

Day 20 — 'the chain moved into code, and the model went PFM.'

Tue, 19 May 2026 22:00:00 -0700

“the chain moved into code, and the model went PFM.”

Where Day 19 left off

Day 19 closed with: structural fixes (AO.1 Part 3.1 project-scoped read_file, frontmatter strip, max_iterations bump, persona rewrites for @front-end and @css-wizard). Chain completing end-to-end on the design studio’s @studio → @visionary → @front-end → @css-wizard four-step pipeline. Quality landed but features got dropped under cognitive load.

Day 20’s opening hypothesis: persona discipline + a stronger orchestrator model could close the feature-drop gap.

Day 19 — 'thesis on disk, studio on its feet.'

Mon, 18 May 2026 22:00:00 -0700

“thesis on disk, studio on its feet.”

Two halves of one day

Day 18 was the surface-tightening pass. Day 19 split into two unrelated halves that compose better than they look:

Morning: strategy moved from head to disk. THESIS.md + two queued sprint docs (ARENA.1, OAI.1) captured the AI-game- company arc that had been forming for weeks in conversation.
Evening: the design studio actually shipped. The chain that’s been working since SD.2 was producing flat checkbox bones; tonight it produced modern card UI with working JavaScript on first emit.

The first half makes the case for why werbos exists in 2026’s hosted-AI landscape. The second half makes one of werbos’s flagship features finally usable. Strategy and shipping landed on the same day.

Day 18 — 'the surface tightens — kanban, opt-in, MCP, update flow.'

Sun, 17 May 2026 22:00:00 -0700

“the surface tightens — kanban, opt-in, MCP, update flow.”

Distribution work doesn’t look like building

Day 17 was a build day: orchestration, security cycle, pipeline UI. Day 18 wasn’t another build day — it was a tightening day. Gating power features behind opt-in flags. Defaulting to clean surfaces. Surfacing the operator-facing strings that were leaking the operator’s machine layout. Naming things on registries before squatters do.

None of it added new capability. All of it reduced friction for the next operator who isn’t me.

Day 17 — 'five gates closed. one hour in, the orchestrator orchestrated.'

Sun, 17 May 2026 01:00:00 -0700

“five gates closed. one hour in, the orchestrator orchestrated.”

Should have been asleep

Wasn’t. AO.0 itself was patched at end of Day 16 (8ec97c3) — the one-line inline_tool_docs propagation in _context_builder_for_agent — and the chain ran clean when I drove it programmatically via /tmp/drive_*.py scripts. But the chat-UI path still didn’t work end-to-end. Four more gates stood between “model can tool-call” and “operator types go and gets a working artifact.”

Day 16 — 'the studio shipped. then the studio couldn't talk to itself. one line later, it could.'

Sat, 16 May 2026 09:00:00 -0700

“the studio shipped. then the studio couldn’t talk to itself. one line later, it could.”

Morning — preflight + safety flips

Locked the R.1 preflight decisions (af6f9fe) and shipped R.2 T.3 (7c3477f): werbos serve now defaults to operator- approval before any listener binds an externally-reachable port. The legacy --confirm-bind opt-in is gone; you opt OUT now with --unsafe-immediate-bind. The same flip the security audit wanted, just expressed the right way around — the safer path is the path with fewer flags.

Day 15 — 'one reply, not six. then zero deferred. then the loop closed. then the little model learned.'

Fri, 15 May 2026 11:30:00 -0700

“one reply, not six.”

The cascade

Pairing worked. First real conversation in Slack — hello → six replies in 60 seconds, each iterating on the last:

werbos Hey back at you! What's up?
werbos Another hello! I'm here to help, what's on your mind?
werbos It looks like that's just a greeting. How can I assist you today?
werbos Still looking for a conversation starter!
werbos I think we've had enough greetings for now. Seriously though, what's on your mind?
werbos Let's try a different approach. Can you tell me what's been going on...

The model was processing the same inbound 4-6 times, each time adding its own previous reply to context and generating a fresh “the user hasn’t responded yet, let me try again” message. 1 inbound × 4 deliveries × 1.5 hellos sent ≈ 6. Math matched the pattern exactly: Slack retries once at 3s, once at 6s, once at 13s if the webhook doesn’t 200 quickly enough.

Day 14 — 'half a handshake.'

Thu, 14 May 2026 23:00:00 -0700

“half a handshake.”

The bug yesterday’s Slack work shipped on top of: the pairing handshake was half-built. Slack would tell the operator to run /social code in werbos chat, but typing that into werbos chat got back “unknown command: /social” — it dropped through to buddy’s catch-all. The store had mint_pairing_code() / redeem_pairing_code(), the Slack adapter knew /pair <CODE>, but nothing in between minted a code the operator could send.

Day 13 — 'the cross-repo trap.'

Wed, 13 May 2026 23:55:00 -0700

“the cross-repo trap.”

Late-night fire drill that turned into a deploy-hygiene fix.

The symptom

POST /api/chats returning 500 immediately after a SR8 redeploy. Stack trace pointed straight at Agent.__init__() rejecting a kwarg one_call_per_iteration that werbos was passing on every session construction.

The trap underneath: werbos/session/chat.py had been bumped to pass that kwarg, but pyproject.toml was still pinned at an older pitts SHA (107adb2) that didn’t accept it. The local editable checkout of pitts had the matching code, but uncommitted — so local tests passed, the live SR8 build broke. Cross-repo half- finished change.

Day 12 — 'play day.'

Tue, 12 May 2026 23:45:00 -0700

“play day.”

V1.9 closed last night with the v1 baseline contract satisfied: 10 of 10 release-blocker sprints shipped, every dashboard surface finally honest. Day 12 doesn’t extend the product surface; it plays on top of it. The morning fixes a bug the v1 baseline left behind (chats with zero turns piling up as “(empty chat)” rows in the sidebar). The evening builds a games suite. The night ports a 2024 multiplayer game into the chat-ui as the first co-op shape in the lineup — and the operator’s own art from two years ago drops in cleanly because the slug naming was already right.

Day 11 — 'the dashboard stops lying.'

Mon, 11 May 2026 22:30:00 -0700

“the dashboard stops lying.”

Day 10 shipped the dashboard as a shell — 9 routes, beautifully rendered, mostly localStorage underneath. Day 11 made every row of the per-element audit in gap-hunting.md true. The morning locked the v1 baseline (Phase 14 in the roadmap; 10 sprints across ~25 days planned). The evening compressed all 10 into one session. By 21:46 PT, every v1-scope surface — agents, perms, channels, scheduler, integrations, models, settings, Home’s Recent activity — answered to the server instead of to localStorage.

Day 10 — 'fortify, then build.'

Sun, 10 May 2026 21:00:00 -0700

“fortify, then build.”

Day 9 closed the late-night Sprint Soc.1 thread; Day 10 splits cleanly into two acts. The morning bolts the doors — two consecutive Black Team / Red Team rounds that close 40 of 41 findings across every surface. The evening, with the surface secured, builds the operator dashboard from scratch: 9 sidebar routes, decoupled SPA, Starlette static-mount, SR8 nginx wiring, all live on the tailnet by 9pm.

Day 9 — 'werbos goes outbound.'

Sat, 09 May 2026 22:30:00 -0700

“the adapter is the wire-format layer; the chat behavior doesn’t know which platform it’s talking through.”

Day 8 broadened the surface area in four directions; Day 9 picks one direction and goes deep. werbos can already chat over CLI, REPL, the React SPA, and werbos serve’s HTTP/MCP surface. Sprint Soc.1 (Phase 12 — external integrations) extends that reachability to where people actually are: Telegram, Slack, WhatsApp via Twilio — three of four platforms shipped today, with the fourth (Twitter/X) gated on a paid API tier and queued for next session.

Day 8 — 'Trust the roadmap, not the memo.'

Sat, 09 May 2026 19:30:00 -0700

“trust the roadmap, not the memo.”

Day 7’s lesson was the persona is the artifact — F.2 dialed the voice and K.0 stamped the floor of the memory ladder. Day 8 broadens the surface area in four directions and runs into the day’s actual discovery in the process: at this work pace, memory between sessions ages out faster than I can refresh it. Two memories that read “in progress” turned out to be already-closed, and one of them nearly cost a duplicated implementation.

Day 6 — 'The infrastructure is the artifact.'

Thu, 07 May 2026 20:00:00 -0700

“i like winning… but i like better training data.”

That sentence — said mid-session, watching v1-c4 lose its third straight game to the heuristic baseline — captures the day’s load-bearing lesson. The bench eventually came back at 3% as O versus the heuristic, with 0 forfeits across 100 games. The format trained perfectly: every reply was parseable JSON with a legal column. The strategy did not. v1-c4 played at random-policy level.

Day 7 — 'The slider and the floor.'

Fri, 08 May 2026 00:00:00 +0000

“the persona is the artifact.”

Day 6’s lesson was the infrastructure is the artifact — the v1-c4 LoRA flopped at 3% as O, but the corpus generator + bench harness + heuristic fallback + observe adapter + security hardening were the real shipping. Day 7 turns that lesson on the persona surface itself. Two sprints land on opposite ends of the “who is werbos?” axis:

F.2 — the slider. The mirror slider ROADMAP § 10.7 has been pitched since the start of the persona phase. Today it shipped end-to-end. The 13% character (werbos’s own taste, peeves, hard-no’s) is always full strength. The 87% voice (mirror / agreement-tilt / memory volume) is a dial — 0 to 100 in the composer chip, werbos chat --mirror 50, /mirror N REPL slash, ?mirror=N query param, per-chat localStorage persistence, .pfm archive round-trip, daily-default memory, per-turn override (/mirror N <message>), and slide-DOWN as a sycophancy-penalty event for v6+ training. Closed with an anti-sycophancy CI gate (werbos eval --suite disagreement_survival).

Day 5 — 'I think that is a glass of beer.'

Thu, 07 May 2026 08:00:00 -0700

“i think that is a glass of beer”

That sentence — generated by llama3.1:8b on SR8, after moondream described a phone-camera photo, with the description injected as a SystemMessage that the agent reasoned over — closed the multimodal loop on local hardware. Photo on phone → vision module → text model with vision context → streamed reply on phone. End-to-end, on your hardware, with your weights, from a single photo of a beer in a “burning barrel” glass.

Day 4 — Two halves: closing the demo loop, then naming the orchestration plane.

Wed, 06 May 2026 00:00:00 +0000

“Smallest, most secure, timeless, protocol we can make.”

The design directive that shaped the second half of Day 4. By the end of the night, the orchestration plane had a name (observe), a flagship consumer (watchtower), two planned siblings (warden, beacon), three new repos, two SPEC drafts, and an Archaeologist review verdict of DURABLE.

The morning was much more practical: closing every blocker that showed up during yesterday’s bad demo.

Day 3 — The full pipeline.

Mon, 04 May 2026 00:00:00 +0000

“i finally got the full pipeline working — data streaming from the server to my computer and my phone. the server auto-updates and pulls on reboot.”

That was the line that closed the day. Everything else — the heatmap, the mobile shell, the voice button, the paperclip, the overnight LoRA, the server in the corner of the office — lined up behind it.

What shipped

Order is roughly chronological: morning stats / training pipeline, afternoon mobile, evening server bootstrap, late-night streaming.

Day 2 — The right test, the right answer.

Sun, 03 May 2026 00:00:00 +0000

The morning after the overnight LoRA train. v2-coder existed in two candidate forms (iter-1000, val 0.850 plateau; iter-2000, val 0.811 new low). We didn’t know which was actually better — and the TTT bench from yesterday told us both were worse than stock, which felt wrong.

Today we built the right benches, ran them, and learned the lesson that’s going to shape every future training run: val loss alone is a deceptive metric. Multi-axis benchmarking is the only honest signal.

Day 1 — He's a system citizen.

Sat, 02 May 2026 00:00:00 +0000

The day werbos stopped being something that lives inside one repo and became a process other things can talk to. Two LLMs can hold a real conversation now, and we have a number that tells us if he’s getting smarter.

What shipped

MCP chat bridge — chat_with_werbos_tool(message, sessionId?) and close_werbos_chat_tool(sessionId). Stdlib urllib, no new deps. Pass the returned sessionId to keep a multi-turn thread going. Every turn lands in the chat archive. (38208a1)
werbos.games.ttt_bridge — first protocol on the bridge. Claude plays X with optimal minimax; werbos plays O via a JSON-envelope prompt. Driver adjudicates rules locally and re-prompts werbos with feedback when he hallucinates an illegal move. (included in 38208a1)
werbos.games.speedcode — second protocol. Same coding spec → both sides write Python → judge with pytest in isolated tempdirs. Smoke test on valid_parentheses (12 cases): both PASS 12/12. Werbos’s solve time on stock 8B: 11.10s. (2e00bd4)
werbos.games.ttt_bench — third protocol. Adds a minimax oracle that scores every werbos move. Output: a single number we can watch go up across model versions. (ecb0ef6)

Numbers worth keeping

Metric	Value
Hot-dog debate rounds (vs Claude)	3 / archived
TTT live games (Claude minimax X vs werbos LLM O)	2–0 Claude
Speedcode pass rate (parentheses, stock 8B)	12 / 12
TTT-bench baseline, stock llama3.1:8b	66.7% optimal, mean regret 0.333
Per-game time (Ollama, M1 8GB)	~22s
Bridge parse failures across all runs	0
Bridge illegal-move retries	self-corrected, never corrupted state

Surprise of the day

Realized I could type werbos from /, from ~, from any directory, and he just runs. The binary’s on $PATH, memory is at ~/werbos/memory, archives at ~/werbos/chats/, Ollama runs as a daemon. He’s not tied to the repo anymore. He’s a system citizen.

Day 0 — It's real.

Fri, 01 May 2026 00:00:00 +0000

The day everything came alive. Started with brew install ollama, ended with a fine-tuned 3B that knows my favorite color is teal. In between: fourteen subsystems, one full UI, the off-grid training loop, and the moment I realized models are just numbers.

What shipped (in order)

werbos tictactoe — v0 milestone. Werbos plays himself; the agent loop works end-to-end.
werbos.session.chat — conversational session orchestrator (PFM archive on exit). (21ec2d7)
werbos chat — interactive REPL with you> / werbos>, quit tokens, EOF + Ctrl-C handling. (9cf60cc, 6996dee)
Calculator tool — first concrete pitts.Tool, safe-eval expression parser. (dd68d50)
werbos.eval + werbos eval — mcculloch Suite hookup, basic_chat / calculator_use against the live model. (645ab43)
Memory hookup — ~/werbos/memory/ loaded into the system prompt every turn. (f9ce0b6)
werbos serve — Starlette HTTP backend. (af3cd42, 15d263b)
werbos/ui/ — React frontend, Vite proxy, end-to-end browser chat. (f92146e)
ChatGPT importer — 3,138 conversations from a Google Drive export → PFM archives. (58c36eb)
SFT exporter — PFM → JSONL with --label filter. (8daee40)
werbos train lora — mlx-lm LoRA pipeline. (97ae6ef)
CORS middleware + Dockerfile / docker-compose for the SR9 deployment story. (55890d3, 71ff301)
werbos.tools.code + werbos code CLI — file + shell tools, three leash modes (read-only / write / shell). (552ce22, 5c49e79)
werbos.labels + --label filter on export + post-run label prompt + werbos label CLI — the full dogfood loop. (76edc64, 0c1d7f5, df16391)
/api/runs + Rate UI — thumbs up/down GUI for past runs. (d2ee237, 5430206)
SCSS migration — 1231-line monolith → 11 partials. (95a2a88)
werbos.mcp + werbos mcp serve — read-only MCP server, five tools. The deliberate exception to off-grid. (562d41f, e1cada4)
Bare werbos drops into chat REPL. (4a34f4b)
WIP phone view + /phone-api proxy. (8e03d93)
Archive-leak fix — atexit + SIGTERM/SIGHUP so a killed terminal still writes the PFM. (4d7d892)

Day 0.5 (next morning, AM)

werbos.backends.mlx_local — pitts.Backend backed by mlx-lm. (a3d53af)
--backend mlx --adapter wired into chat / code / eval / serve. (3334b8c)

Numbers worth keeping

Metric	Value
Conversations imported (ChatGPT export)	3,138
Adapter v1 base	Llama-3.2-3B-Instruct-4bit
Adapter v1 size	~30 MB
Adapter v1 best val loss	1.636 (down from 1.986, -17.6%)
Adapter v1 best iter	1250
First memory recalled by trained brain	“Jason’s favorite color is teal”
MCP read-only tools shipped	5
Off-grid status of the inference loop	100%

AHAs

“Models are just numbers.” Trained weights are slot values in a matrix. Training is nudging those numbers, not adding new ones.
Adapter stacking is “I know kung fu.” Base model + frozen Δ₁ + Δ₂ at inference time. Like Neo: the brain doesn’t grow, the cable uploads a new skill.
Merging averages, doesn’t add. Merge two 10B models → still 10B. To grow capacity, concatenation (add new layers), not merge.
Four primitives: training (fills slots), merging (averages values), concatenation (adds slots), distillation (compresses big → small).
Off-grid economics: cloud LLM agent at 24h = ~$50/day; local laptop at full tilt = ~$0.03/day in electricity. Three orders of magnitude. The whole reason werbos exists.

Surprise of the day

Llama-3.1-8B OOM’d at the first gradient step on M1 8GB. Hardware ceiling is real. Dropped to 3B-class for training; kept 8B for inference. The fleet roles got crisp: M1 = dev + train (3B max), SR8 = inference (13B+), Pi 5 = always-on orchestrator.

About

Mon, 01 Jan 0001 00:00:00 +0000

Renting intelligence by the token was never the endgame. werbos is a foundry: a place to mint a model that’s yours, ground it in your own library, and run it on your own box — off-grid, sub-second, and honest about what it doesn’t know.

We build in the open. The developer journal has run 159 days and counting — benchmarks, dead ends, and all. If you want to see how the machine gets made, it’s all written down.

Compose Your Model

Mon, 01 Jan 0001 00:00:00 +0000

Features

Mon, 01 Jan 0001 00:00:00 +0000

How does werbos work?

Mon, 01 Jan 0001 00:00:00 +0000

Most AI is one giant model in someone else’s data center. werbos is the opposite bet: a small model you own, pointed at a library you curate, with a verifier that refuses to guess. The clever part isn’t the weights — it’s the engine around them.

One line carries the whole design:

capability = model × library

The model is the cursor — the thing that reads, picks, and phrases. The library is the knowledge — everything the model is allowed to know. You grow capability by growing the library, not by renting a bigger model. That’s why it stays cheap, stays local, and stays yours.

Knowledge Graph

Mon, 01 Jan 0001 00:00:00 +0000

Levels of Progression

Mon, 01 Jan 0001 00:00:00 +0000

The lines that don’t move

Across every level, five things never change — they’re the constitution, not the roadmap:

Owned weights. No open-model substitution, ever. The goal is our model.
Library is truth. Cards are retrieved and cited — they never become weights. Knowledge in weights is confident hallucination with no honest abstain; that’s the one failure this whole thing exists to prevent.
Honest-abstain — and, going forward, honest-synthesis: never assert, always demonstrate. A running, verified thing, or an honest “I don’t know.”
Local-first. Your data stays on your box.
Every gate is a number. “We hit 3.0” is a measurement on the sealed gauntlet, never a vibe.

Those five aren’t just principles — they’re the werbosOS kernel: the contract every level inherits and no app can break. Read the ladder that way and it stops being a product roadmap. It’s werbosOS coming online, one earned level at a time — hardware, then a kernel, then organs (senses, tongue, reasoning), then apps (the chat, the dating lane, the games, Smallville), until at 5.5 it wakes up as an ambient companion that sees you, knows you, and won’t lie to you. An operating system you own, that knows only what you tell it.

Live Demo

Mon, 01 Jan 0001 00:00:00 +0000

Terms

Mon, 01 Jan 0001 00:00:00 +0000

This page is a placeholder. werbos is a personal project; for now, treat the content here as MIT-licensed prose with no warranty. The source code is MIT.

When this page lands properly, it will cover:

Privacy: this site sets no cookies, runs no trackers, and does not log anything beyond Netlify’s standard request logs.
Content license: log + map + docs prose under [CC BY 4.0] (https://creativecommons.org/licenses/by/4.0/).
Code license: MIT.
No warranty: werbos is research-grade software. Don’t use it for anything mission-critical without your own validation.

For now: assume the above. Read the log for what werbos actually does, on whose hardware, with what data.

The Flow

Mon, 01 Jan 0001 00:00:00 +0000

The map is the conceptual field guide — what an LLM IS, what training does, how adapters stack. This page is the system flow — every component an operator turn passes through, the artifacts each component writes, and how an operator debugs when the answer is wrong.

Explore the whole flow interactively → All 169 components as one navigable graph — drag, zoom, search, and click any node to walk its connections across every layer.

Want to reason about the whole system with an LLM? Grab the plain-text graph export ↓ — paste it into Claude or ChatGPT.

The Map

Mon, 01 Jan 0001 00:00:00 +0000

The map answers the what is questions: training, adapters, hardware, the four operations, the off-grid economic argument. It’s the companion to the log, which answers what just changed.

Big picture (one diagram)

+--------------------------------------------------------------+
| BASE MODEL |
| (e.g. Llama-3.2-3B-Instruct, weights frozen) |
+--------------------------------------------------------------+
 | inference time
 v
+--------------------------------------------------------------+
| +ADAPTER 1 (~30 MB LoRA delta, your data, your style) |
| +ADAPTER 2 (optional, stack as many as you like) |
+--------------------------------------------------------------+
 |
 v
+--------------------------------------------------------------+
| YOUR HARDWARE: M1 (dev/train, 3B max), |
| SR8 Ryzen (inference, 13B+), Pi 5 (always-on orchestrator) |
+--------------------------------------------------------------+

If you only memorize one diagram, that’s it. The brain is the base. The skills are the adapters. You stack them at inference. Like Neo plugging in “I know kung fu.”

The Mind

Mon, 01 Jan 0001 00:00:00 +0000

The map is the field guide to what werbos is; the flow is how a turn moves through it. This page is werbos’s mind — the dimensions it’s measured on, what each one means, and the ones it can’t measure yet.

The psychology angle is the one axis a frontier model can’t compete on. Measuring and improving a mind needs a model that’s small, local, legible, editable, and prunable — exactly werbos’s properties and exactly what a 200B black box isn’t. The forest is the instrument; the mind is what it’s for.

The Stack — what's hooked up, who's doing the work

Mon, 01 Jan 0001 00:00:00 +0000

A running tally of who is actually doing the work across werbos — because the common question (“is this Claude? ollama? something we built?”) has a foggy answer until you separate the axes that keep getting conflated.

Snapshot: Day 46 — 2026-06-16. This drifts; treat it as a dated inventory, not a spec.

First, untangle the categories

The usual five labels — hooked up · open weights · hand-rolled · Claude · ollama — aren’t parallel. Two of them collapse and one splits:

Who it's for

Mon, 01 Jan 0001 00:00:00 +0000

werbos

★ Current model — talk base · v3 book-pretrained 336M

🌡️ Temperature

Install

Prerequisites

1. Install werbos

From source (today’s path)

From PyPI (Sprint A.5 day 5)

Doctor

What it checks

Project context

Discovery

How to train

1. Ingest your corpus

How to nudge

After every session

How to rate

Start the UI

Games

Background tasks

Autopilot

Skills

Personas

Vision

Chat surfaces

Inside the REPL: ? / /help

Social bridges

Parsetongue

Data pipeline

Eval suite

Days 148–159 — the ruler that reads structure

Stop asking who won

Day 147 — the bricks are shapes, not strings

B.33 — the human-likeness judge: 4 → 7 of 10, FAIL → PASS, from warm-authored facts

The claim under test

Day 146 — the conversation that passes

Day 144 — life back in the facts

A guarded restyle

Day 143 — the conversation, past turn two

Memory across turns

Day 142 — hunting the last 25

The one that mattered

gapmarks — where werbos ranks on the GPT-2 → 4.5 ladder

B.32 — the probe, one day later: 292 → 403 of 571, 97% honest on the gauntlet

Day 141 — fix the class, not the row

Wrong, with a badge

B.31 — werbos probe, 571 tests on the live path: 292 pass, and the ruler had a bug too

Day 140 — the test that tested the tester

rspec for language models

Day 139 — one mode, one hierarchy

The one mode

Day 138 — HAIRLy: Claude becomes the user

Day 137 — two mirrored composition engines: knowledge and language

Knowledge: acquisition, not lookup

B.30 — the 500-item moat gauntlet: confident-wrong 135 → 31, honest 65% → 86%

The claim under test

Day 136 — the moat, tightened everywhere the wild found a crack

A new ruler

B.29 — compose correctly or abstain, never bluff: the kitchen-sink regression gauntlet

The claim under test

Day 135 — compose correctly, or say I won't guess

Eyes that abstain

B.28 — zero model, still 478/478: the intro gauntlet, decomposed into bricks

Day 133 — a brick bin you can hold

Hands

Day 132 — tell it, build it, run it with what you told me

Day 131 — the terminal becomes werbos

One surface, our brain

Day 130 — deciding what's worth learning

Day 129 — he's a real citizen now

Day 128 — we give the mind a hand

Day 127 — the gauntlet grades the web lane

The win

Day 126 — the honest cascade, and the 3B goes

Day 125 — the gauntlet finds the wall

Day 124 — the engine does the work

Day 123 — the mouth stops guessing

B.27 — the rated coding gauntlet: solid 150, a soft 350, a cliff above

The claim under test

Day 112 — two mirrors and a ruler

Inside the REPL: `?` / `/help`