Day 137 — two mirrored composition engines: knowledge and language
The night the thesis stopped being a metaphor. werbos already builds computation from interlocking bricks; today it got the same machinery on both other sides. A knowledge-acquisition layer: 98 free sources indexed by what they cover and how to reach them, a universal API caller, offline datasets that answer 'atomic number of iron' with no net — and the payoff, an acquisition loop where one question harvests an entity's whole neighbourhood into cards, so 'capital of Australia?' quietly fills four cards and the library grows itself from use. And a language layer: conversation composed from a small vocabulary of rhetorical moves that interlock exactly like the compute bricks, with the 1B wired as voice-only — it strings the grounded ideas, it can't invent them.
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.
A single universal caller (plug in a URL, get a response — cached, guarded, honest when it fails) sits under all of it. Small static datasets — the periodic table, country data — are bundled, so “atomic number of iron” answers 26 and “capital of Australia” answers Canberra with the network unplugged.
And then the part that matters: acquisition, not just answering. Ask “capital of Australia?” and werbos resolves the Australia entity and harvests its whole neighbourhood — capital, currency, region, language — minting each as a cited card. One question quietly becomes four. Ask “currency of Australia?” next and it answers from the card it just made, offline, no lookup. The library grows itself from real use. An API stops being a feature and becomes a knowledge refinery.
Language: the same bricks, in rhetoric
A good paragraph isn’t one thing a model memorized — it’s a handful of rhetorical moves in order:
observe, name, reframe, contrast, generalize, exemplify, recommend, riff, close. And the sequence of
moves is a program. “Should I move cities for this job?” runs an advice program (problem → solution
→ the pivotal question → boundary). Explaining an idea runs an insight program (observe → name →
generalize → contrast → close).
The moves interlock like the compute bricks — the solution consumes the problem, the advice consumes both — chained, then combined into one reply. And here’s the thesis, made concrete: the program is testable without the model at all. Feed the right pieces and a tiny 1B only has to connect them. So the 1B is wired as voice, not brain — it strings the grounded beats into natural prose, and a guard makes sure it connects without ever inventing a fact that wasn’t in the skeleton. The lanes provide the grounded content; the tongue just talks.
The symmetry
KNOWLEDGE api → facts → cards → relationships → reasoning
LANGUAGE thought → semantic bricks → rhetorical bricks → voice → sentence
Same machinery, both sides. It’s the coding-moat idea — capability = composer × library, the model is just the cursor — generalized to everything werbos knows and everything it says. The intelligence lives in the composition. The 1B is the tongue.
The funniest proof came for free: a chat, explaining this back, answered in observe → name → generalize → contrast → close — the exact insight program werbos now composes. The architecture
demonstrated itself.
Later: the three dials
Three follow-on bricks finished what the two engines started — and turned “we have lanes” into “we have tunable conversational shapes.”
The acquisition loop went unbounded. This morning it only harvested bundled entities (the
periodic table, country data). A Wikidata consume-harvester now resolves any entity to a single
Q-id and pulls a curated set of structured relations into claims — scoped to Wikidata’s real strength
(the gazetteer: capital, currency, population, is-a), not prose. Net-unplugged it returns nothing and
never reaches out; cached, the second ask is offline. And it emits is-a claims — the relational layer
a reasoner walks.
The two engines interlocked. describe is the seam where they meet: harvested facts flow into the
rhetorical bricks and the 1B strings them into a sentence — grounding-guarded, so a voice that tried
to add “ruled by King Zog, 500 billion citizens” is rejected and the plain version ships instead.
Knowledge produces the facts; language voices them; the guard guarantees the tongue only connects.
And conversation got a third dial. The move vocabulary grew — reflect, validate, normalize
for therapy; plan, verify for coding; boundary for the honest edge — and each prompt type got its
own shape: therapy always ends on a boundary, coding always ends on a verification, a life-riff
never abstains, small talk stays a sentence. The shape itself carries the contract. Now there are
three orthogonal dials: the intent picks the shape, the lane fills the bricks, the tongue
voices them. Same machinery, three knobs — dial in the conversation you want.