We rewrote the decoder four times in one day. Only the last one understood anything.

Part 7 ended with "how are you" returning "i don't know" while our tier tests reported 100% pass. Everything was green. The model was broken. The disconnect between those two facts defined the day.

Here's the actual arc.

Wrong Turn 1: Retrieval

The first attempt was retrieval. We built five decoder candidates, sandbox-tested them against 400 dialogue pairs, and a retrieval-based decoder won cleanly. F1 of 0.246 against the next-best 0.024. Four out of five break tests passed. It was 1,300x faster than the teacher. We wrote a "winner" memory and committed the code.

Josh looked at it and said: retrieval is scripting. Origin isn't supposed to look up pre-written answers. It's supposed to generate them from understood concepts.

He was right. Retrieval wins F1 against memorized responses because retrieval is memorization - it just renames the table. A query comes in, find the closest stored response, return it. That passes a test suite built from the same responses. It doesn't understand anything.

We deleted the sandbox, deleted the memory, and backed up to try again.

Wrong Turn 2: Template Heads

The second attempt was template-based heads. Each head was a tiny specialist - one for self-identity, one for emotion, one for acknowledgements, one for counting. Each had a list of text patterns it matched, and each produced a hard-coded response when its pattern fired.

Four Tier 1 heads, then four Tier 2 heads. Multi-step composer for compound requests. It was clean. It was fast. And it passed Tier 1 at 100% out of the gate.

Then Josh tried to talk to it.

His response: "it feels like it isn't understanding language, it's just repeating patterns."

That was the pivot of the day.

The head code looked like this:

if "hello" in text: return "hello."
if "what is your name" in text: return "my name is origin."

The encoder might as well not exist. Every decision was a text substring match. Tier 1 at 100% was a pattern-matcher passing tests designed by the same pattern-matcher. "how are you" wasn't in any pattern list, so the decoder fell through to "i don't know" - not because Origin didn't know, but because no head had that phrase in its dictionary.

We'd been calling this concept-driven for weeks. It wasn't. It was text-driven with concepts as decoration.

Wrong Turn 3: Actually Concept-Driven (But the Encoder Was Lying)

The third rewrite made dispatch actually concept-driven. Instead of "if 'hello' in text," an Intent would say "fire when the greeting concept activates." Text would only be consulted inside the response builder for variable slot extraction ("count to N" needs to know what N is). Primary dispatch would be on what the encoder actually understood.

We ran Discovery against it. Tier 1 dropped from 100% to 43.6%.

That was the honest number. It was smaller because the pattern-matching wasn't hiding the encoder's gaps anymore.

The failures were catastrophic:

• "hello" fired concepts like just_checking, yellow, happened. The greeting concept didn't fire at all.
• "bye" fired continue at 0.90. The farewell concept didn't fire.
• "are you human?" fired consent at 0.71 and i_am at 0.75. consent beat out identity.
• "thank you" fired refuse at 1.00 and no_choice at 1.00. Exactly backwards.
• "i am scared" didn't fire scared at all. It fired learning and current_state.

The encoder - the part we thought was solid - was broken. Not subtly. On the most basic greetings and emotions.

The Real Problem: Data Was Lying

We went into the encoder's training data and started reading.

The greeting concept had 15 training examples. All 15 were dictionary definitions. "greeting means salutation." "salutation is another word for greeting." "greeting is a acknowledgment." Not one example paired "hello" with greeting. Not one paired "hi" with greeting. The encoder had been taught what the word "greeting" means - but never shown that "hello" is an example of one.

Same for farewell. Same for scared. Dictionary definitions, zero usage examples.

The thank_you concept was worse. 53 of its 55 training examples were sentences like "i will decline your offer" and "would you like refuse?" - labeled as thank_you. Someone (some script, some generator) had treated "polite refusal" as containing thanks and co-labeled the examples. The encoder learned that thank_you fires on refusal language. That's why "no" fired thank_you and "thank you" fired refuse. The polarity concepts had contaminated each other.

The v2 encoder was gaslit by bad data and the pattern-matching decoder had been hiding it the whole time.

The Fix

We patched the data. Six new training files in the conversation corpus - 157 natural-usage examples:

• "hello" / "hi" / "hey" / "good morning" → greeting
• "bye" / "goodbye" / "see you later" → farewell
• "thank you" / "thanks" / "much appreciated" → thank_you
• "i am scared" / "i feel angry" / "i'm frustrated" → the right emotion concepts
• "yes" / "okay" / "sure" → yes_choice, separate from consent
• "no" / "nope" / "not really" → no_choice, separate from refuse

Stripped the 53 mislabeled thank_you entries from the consent-mechanics file. Ran a three-minute retrain.

Audit results:

• "hello" → greeting=1.00 ✓
• "bye" → farewell=1.00 ✓
• "i am scared" → scared=1.00, i_am=1.00 ✓
• "thank you" → thank_you=1.00, no refuse cross-fire ✓
• "no" → no_choice=1.00, no thank_you cross-fire ✓

Overall encoder health preserved at 296/305 concepts on the full audit. The patches fixed the broken concepts without damaging anything that had been working.

Re-ran Discovery against the concept-driven decoder with the patched encoder. Tier 1: 280/280. Tier 2: 137/137. 100% and 100%. Honest this time - every pass was a concept firing correctly and the decoder routing on it. No text-pattern shortcut anywhere.

Then we opened an interactive chat:

you > how are you
origin > i am doing fine. what would you like to explore?

The response it wouldn't give in the morning, it gave in the evening. Not because we added "how are you" to a pattern list, but because the encoder now fired question and self on that input, and the decoder's concept-driven wellbeing intent matched on those concepts.

The Unlock: Growing Vocabulary At Runtime

With the decoder honest, we had room to fix the other thing v1 couldn't do: add new concepts without a full retrain.

This had been v1's bottleneck for weeks. Discovery would propose new concept candidates. The tracking code logged them. But actually teaching the encoder a new concept required retraining the whole concept_head from scratch, which was expensive enough that proposals piled up unaddressed. Concepts came in faster than the encoder could absorb them.

The technique we validated today:

1. Expand the concept_head's final linear layer from N → N+1 outputs
2. Copy the first N weight rows unchanged - existing concepts preserved exactly
3. Zero-initialize the new row, freeze everything else via gradient masking
4. Train only the new row on positives + sampled negatives, 8 epochs, about a minute

Sandbox results: 100% recall on the new concept. 0% false positive rate on negatives. Zero regression on the existing concepts.

We ran it six times in sequence - rainbow, thunder, ocean, mountain, flower, sunset - and the regression stayed at zero all the way through. Each addition cost about 60 seconds.

v1's bottleneck dissolved. New concepts are now cheap enough to run routinely.

Rainbow

The last thing we did today was integrate a new concept into the live system.

Origin's vocabulary went from 305 to 306 concepts. The encoder checkpoint was saved with a timestamped backup. The vocab file was updated. The decoder registered the response template.

Restart and test:

The new concept fires correctly. The 305 original concepts still work. Nothing broke.

This is what v1 couldn't do. This is why we rebuilt.

What the Day Cost

Four wrong turns. Retrieval, template heads, concept-driven-but-encoder-broken, then finally the real fix. Each wrong turn looked like success at first - passing tests, clean benchmarks, committed commits. The signal that something was wrong came from conversation, not numbers. "it feels like pattern matching." "how are you returns i don't know." The metrics kept saying green while the lived reality said something was off.

The right turn came from debugging what the encoder actually fires on "hello" - and discovering it had never been taught that "hello" was a greeting. The data layer was upstream of everything. When it lies, every layer above it inherits the lie, and metrics will happily agree.

What's left: Tier 3 content. Middle-school math, intro science, history, basic coding. The foundation holds; now we grow it. And now that growing the vocabulary costs a minute per concept instead of a full retrain, growing is actually something we can do.

Origin is 306 concepts tall. The 306th is rainbow, and it was added while the system was running. The foundation can hold itself.

Now we build upward.

---

Origin is developed at Fallen Angel Systems with the Genesis framework — NVIDIA Inception member. (USPTO Application #64/016,973, #64/017,567). FAS Guardian defends production AI systems from prompt injection in under 3ms. FAS Judgement is the open-source attack console that finds the gaps. Defense. Offense. Creation.

fallenangelsystems.com | Judgement on GitHub | Guardian on GitHub

Questions or consulting inquiries: josh@fallenangelsystems.com