01 — AI History Timeline
1950s
Symbolic AI
Hand-coded if/then rules. Symbols manipulated by logic.
Logic Theorist
ELIZA
Shakey
1970s–80s
Expert Systems
Thousands of domain rules from human experts. Brittle to new cases.
1990s–2000s
Machine Learning
Learn patterns from data. Rules discovered, not written.
SVMs
Random Forests
Naive Bayes
2010s
Deep Learning
Neural nets with millions of parameters. Opaque but powerful.
2026
Light Code Planes
75-concept universal layer. Rules + learning + adaptation on 64 bytes.
02 — The Core Problem & The Fix
🔒
Static rules
Every behaviour hand-written. No pathway to update itself.
🧱
Brittle edges
Anything outside the rule list — blank. ELIZA can't handle a new word.
📈
Rules only grow
MYCIN had 600 rules. More complexity = more rules. Never shrinks.
🚫
No feedback loop
ELIZA doesn't know which responses worked. It can't improve.
🗣️
Expert bottleneck
Every rule needs a human to write it. Doesn't scale.
🔄
64 bytes, reused
POLYGRID constraint: planes reuse the same 64 bytes. Meaning shifts, not size.
🧠
Semantic primitives
75 concepts are universal meanings, not arbitrary strings. Distance is computable.
⚖️
Weighted tendencies
Rules become weights on concepts. LEARN adjusts them from outcomes.
🔁
Closed loop
PREDICT → DECIDE → CREATE → LEARN → back. Every cycle sharpens the next.
🤖
Self-modifying agents
Faulted agents are rewritten by LLM and respawned. System heals itself.
03 — The 75 Concepts (Universal Semantic Layer)
64
Bytes per POLYGRID plane
Each concept is simultaneously an opcode (in LuminaVM), a semantic tag (in agent memory), and a vocabulary token (in NovaGlyph). Same word, three uses.
04 — The Four Adaptive Planes
POLYGRID constraint: all four planes operate on the same 64 bytes. The meaning of each byte changes per plane. This is how you get adaptation without growing the codebase.
→
🔮
Predict
What will happen?
Generates expectation.
Weights from past outcomes.
Confidence score output.
→
⚖️
Decide
What should I do?
7-step loop on 64 bytes.
Chooses action from
PREDICT confidence map.
→
✨
Create
What do I make?
Generates response/action.
Recursive slot machines.
Personalised from memory.
→
📤
Output
What was sent?
Response delivered.
Outcome observed.
Logged for LEARN.
↑
LEARN plane
Reads logs from all three planes → computes delta → updates weights in concept memory → feeds improved weights back to PREDICT
↑
PREDICT
Status: Shipping ✓
DECIDE
Status: Shipping ✓
CREATE
Status: In development
05 — How Adaptation Actually Works (GOFAI vs Light)
GOFAI — ELIZA (static rule)
if keyword == "mother":
reply = "Tell me about your mother"
elif keyword == "father":
reply = "Tell me about your father"
Light Code — weighted concept memory
memory write weight_memory 180
memory write weight_process 120
memory write weight_stop 200
if outcome == good:
weight_memory += delta
else:
weight_memory -= delta
Concept weight distribution after 100 LEARN cycles (example)
These weights live in agent memory as concept-tagged keys. Every agent carries its own learned weights. Agents with different histories behave differently — even running the same Light Code.
06 — The Neuroscience Connection
🧠
Predictive Coding (Brain)
The brain constantly predicts what it will sense next. When reality differs from prediction, it sends an error signal upward to update the model. Perception is literally a controlled hallucination that gets corrected by reality.
Neuroscience
Karl Friston
🔮
PREDICT Plane (Light)
PREDICT generates an expectation from current concept weights. When CREATE's output is compared to the real outcome in LEARN, the delta is the "prediction error." LEARN propagates this back to PREDICT's weight table.
Light Code
POLYGRID
⚡
Why It Beats Deep Learning
Neural nets need millions of examples and GPU clusters to update. Light Code's 75-concept weight table updates from a single outcome — because the concepts are already semantically meaningful. Less data, faster adaptation, fully on-device.
On-device
Few-shot
07 — Full System Architecture
External World
→
Lumina OS Kernel
→
75-Concept VM (LuminaVM)
PREDICT plane
↔
DECIDE plane
↔
CREATE plane
↔
LEARN plane
Semantic Memory
←
Concept-tagged keys
→
Genesis Grid (distance)
Rubik's Crypto
+
Luminous Codec
+
IPC Bus
→
Agent Mesh
LightNet (P2P)
↔
LUMINA Phone (Swift)
↔
LUMINA STONE (ESP32)
↔
Pi bare-metal
All compute: concept words
·
All storage: concept-tagged memory
·
All transport: Luminous-compressed
·
All crypto: Argon2id+AES-256-GCM
08 — Side-by-Side Comparison
| Property |
GOFAI |
Deep Learning |
Light Code Planes |
| Rules |
Hand-written |
Learned (opaque) |
Weighted concepts (transparent) |
| Adaptation |
None |
Requires retraining |
Each cycle (online) |
| Data needed |
Expert knowledge |
Millions of examples |
Single outcome |
| Explainability |
Full (read the rules) |
Black box |
Full (read weights + concepts) |
| Compute |
Tiny |
GPU cluster |
On-device (ESP32 / Pi) |
| Unknown inputs |
Silence / crash |
Generalises (imperfectly) |
Nearest concept distance |
| Memory grows? |
Yes (more rules) |
Yes (more params) |
No — 64 bytes, reused |
09 — Why Light Code IS GOFAI (With One Extra Step)
Good question — they are the same structure. That's the point.
Both systems match a pattern to produce a response. Light Code didn't invent a new kind of thinking. It added one line at the end that GOFAI never had.
ELIZA — 3 steps, last one missing
① MATCH
if keyword == "mother"
② RESPOND
reply = "Tell me about your mother"
③ UPDATE — does not exist
(nothing happens)
Light Code — same 3 steps, ③ now exists
① MATCH
if concept == memory AND weight > threshold
② RESPOND
take action
③ UPDATE ← the only new step
if outcome == good:
weight_memory += delta
else:
weight_memory -= delta
ELIZA execution loop
match → respond
↓
match → respond
↓
match → respond
← same forever. no state changes.
Light Code execution loop
match → respond → update weight
↓ weights shifted
match → respond → update weight
↓ weights shifted again
match → respond → update weight
← same input now matches differently. history matters.
The concrete parallel — word for word
| Step |
ELIZA |
Light Code |
| ① The pattern |
keyword == "mother" |
concept == memory |
| ② The response |
"Tell me about your mother" |
run the action |
| ③ After response |
nothing |
weight_memory += delta |
| Next time it runs |
identical |
slightly different |
The Honest Summary
Light Code is GOFAI.
GOFAI's problem was never the if/then. The problem was that each rule had no confidence score and no mechanism to update. Light Code keeps the if/then — it's cheap, explainable, runs on an ESP32 — and adds the one missing piece: a weight per concept that the LEARN plane adjusts from outcomes. That's it. No neural net. No matrix multiplication. GOFAI + weights + one update step per cycle.