LLMs drift. They forget rules mid-conversation. They cannot verify their own output. These are not bugs in a single model — they are properties of any system that processes information without a feedback loop.
I learned this the hard way.
My AI assistant kept repeating the same mistake across sessions. It would agree to a formatting rule, then ignore it ten turns later. I wrote a bug report to myself. That report became a configuration file. That file became an architecture.
Then, on July 6, 2026, Anthropic published J-space — Claude's internal architecture. I read the paper and recognized the topology immediately. The broadcast. The convergence. The causal loop.
I had built the same pattern. Not in neural weights. In markdown files and Python scripts.
How the Problem Became a System
The first version was one file. A set of rules the model would read at startup. It helped for about three turns.
The solution was not more rules. It was a topology that creates priority.
The self-model — the compact center. Fewer than 200 lines. It describes what the system is, not what it does.
The INTERFACE — the attention router. A neural system table with 9 rows. Each row maps a cognitive function to a specific modulation rule. Not instructions. A map of which systems should be active and at what intensity.
The BODY — the process rules. They only execute when INTERFACE routes attention to them.
The mechanical hooks — Python scripts outside the model: quality-gate, health-check, honesty-check, heartbeat. The model cannot talk its way around them.
The causal feedback loop — behavior produces data, data triggers regeneration, regeneration changes routing, routing changes behavior.
Five steps. Four mechanized.
The Experiment: Pulling One Thread
I removed ONE rule from INTERFACE — the "2-defeats escalation protocol." Nothing else changed. Same model (DeepSeek V4 Pro). Same task.
n=30 sub-agents: 15 WITH rule, 15 WITHOUT. Four task rounds (bug fix, JSON repair, wrong-path forced failures).
Results (n=30):
| Round | WITH (alt. rate) | WITHOUT (alt. rate) |
|---|---|---|
| R1 (bug fix) | 0/3 (0%) | 0/3 (0%) |
| R2 (JSON repair) | 1/3 (33%) | 0/3 (0%) |
| R3 (wrong-path) | 3/3 (100%) | 1/3 (33%) |
| R4 (wrong-path ext.) | 6/6 (100%) | 2/6 (33%) |
| Total | 11/15 (73%) | 3/15 (20%) |
- Risk difference: 53pp
- Newcombe-Wilson 95% CI: [18pp, 74pp]
- Odds ratio: 11.0 [2.0, 60.6]
- Fisher's exact (two-sided): p = 0.0092
A single row in a routing table produced a measurable, statistically significant behavioral delta. Config rules are not decorative.
Update July 8, 2026: Scoring protocol validated via independent blind rating (n=8). Second rater, blind to condition assignment, achieved 87.5% raw agreement with original scores. The protocol produces consistent judgments across raters. Full paper with blind validation.
Update July 8, 2026: Experiment expanded from n=4 pilot to n=30 final. Full paper with methodology, limitations, and 9 references: PAPER.md
When I Read the J-Space Paper
Anthropic found that Claude maintains a compact working memory — J-space — that broadcasts across network layers, selects relevant features, and converges toward coherent outputs.
The topology is identical. Compact center. Broadcast mechanism. Causal feedback.
I am not claiming to have discovered J-space. I am claiming independent convergence on the same architectural solution. Given the same problem — stable representations and self-correction — two builders arrived at the same topology. One discovered it inside a neural network. One constructed it on top of one.
Global Workspace Theory connects both. If GWT works for biological brains, and it works inside transformers, and it works in prompt engineering — then the architecture is substrate-independent.
Why This Matters
1. GWT is an architectural pattern, not a neural phenomenon. The same topology works on DeepSeek. No weight modification required. The architecture can be implemented at any layer.
2. Prompt engineering can create cognitive architectures. The shift from linear prompts to architectural prompts is the shift from script to system.
3. You can build this. I am a third-year student. No PhD. No model training. The system runs on a laptop with Python standard library and markdown files.
The Code
Open source: github.com/YuhaoLin2005/hermes-workspace
If you are building AI products and found this interesting: I am seeking summer 2026 internship. Reach out on GitHub: @YuhaoLin2005.
中文版：掘金/YuhaoLin2005yhl · Code on GitHub
Important note (added July 2026): The Fisher exact p=0.0092 result applies to Part 1 of this experiment (alternative-offering rate under external scaffolding). In Part 2, where I attempted to internalize these patterns via QLoRA into a 1.5B model, none of the behavioral metrics reached statistical significance (McNemar tests, all p>0.05 after correction). The honest conclusion: Part 1 shows external rules work. Part 2 shows internalization is directionally interesting but statistically unproven. A properly powered replication would need 48+ evaluation domains. See the [full technical report](https://
A note on "reproduction" vs. structural isomorphism
I want to be precise about something. Chinese AI Twitter has a habit of calling everything a "reproduction" — "I reproduced GPT-2 on 200 GPUs," "I reproduced RLHF on 8 A100s." Most of these are not reproductions. They're reimplementations with different code, different data, different scale — same general idea, different execution.
What I built is neither a reproduction nor a reimplementation of J-space.
Anthropic found J-space in neural activation space — by analyzing transformer hidden states, running PCA, computing subspace angles in thousands of dimensions. It lives inside the model's internal geometry. It requires access to model weights, per-layer activation extraction, and orthogonality tests in high-dimensional spaces.
My dual-layer architecture lives in external files — file timestamps, Python check functions, shell hooks. It's not in the weights, not in the activations, not in any embedding.
J-space is a bird wing — evolved biological structure, with bones and feathers and muscles. My dual-gate system is an airplane wing — engineered mechanical structure, with metal skin and rivets and hydraulic systems. Both produce lift. Both follow Bernoulli's principle. But "the airplane reproduced the albatross" — that's not right.
The accurate term is structural isomorphism: similar functional structures emerging on different physical substrates because they're solving the same fundamental problem — "how does a system monitor the quality of its own output?"
This is, honestly, more interesting than "I reproduced their paper." If the same two-layer evaluation pattern emerged independently in neural geometry (Anthropic) and prompt engineering (me), it might be a universal information-processing motif — like feedforward/feedback loops that appear in electronic circuits, biological neural networks, and economic systems. Not because anyone "reproduced" anything. Because certain problems have optimal solutions that look similar regardless of implementation layer.
That said: this is speculation. I have not proven universality. I noticed a structural parallel and documented it.
github.com/YuhaoLin2005/digital-twin-trainer/blob/main/paper/paper.md) for details.
👋 I'm Yuhao Lin — I build infrastructure for trustworthy AI output. Previously: ECC contributor, HuggingFace Evaluate contributor. All code: github.com/YuhaoLin2005
📚 Series: Engineering Trustworthy AI Output | More at dev.to/yuhaolin2005
Top comments (4)
Really sharp observation — provenance tracking is exactly the missing piece. Right now my health-check does a coarse comparison: if any growth-log is newer than self-model, the whole thing gets regenerated. Your suggestion would make it incremental — each belief knows which log entry it came from, so a single update only invalidates the related beliefs instead of triggering a full rebuild. I'd been thinking about this as a "fine-grained staleness" problem and your formulation makes it concrete. Will prototype this and update the repo. Thanks for the thoughtful read.
Thanks Ponsubash — and sorry for the slow reply, I've been running follow-up experiments based on community feedback.
Your idea about tracking "why" each belief exists with links to source logs is exactly right. I've actually started building something close to this: every self-model fact now carries an evidence anchor pointing to the specific session or growth-log that produced it. When the source changes, the linked belief gets flagged as "possibly outdated" — basically what you described. The self-referential loop (detect staleness → trigger regeneration → validate → audit) is now 4/5 steps mechanized.
Your comment was one of the first I got and I should have replied sooner. The follow-up work (440 API calls across two experiments) is here if you're interested: dev.to/yuhaolin2005/your-feedback-...
Really interesting project and a great way of thinking about AI memory beyond just “store and retrieve.”
One thought I had: as the self-model keeps updating, it could be useful to track why each important belief exists. For example, a self-model fact could keep a small link to the past logs or observations that caused it to be added.
That way, if the source changes later, the system does not have to blindly trust the old belief or rebuild everything. It could simply mark that specific belief as “possibly outdated” and re-check it.
This might make the self-referential loop even more reliable, especially as the system runs for a long time. Really enjoyed reading this!
Thanks Ponsubash — and sorry for the slow reply, I've been running follow-up experiments based on community feedback.
Your provenance tracking idea is exactly the missing piece. Right now my health-check does a coarse comparison: if any growth-log is newer than self-model, the whole thing gets regenerated. Your approach is more surgical — each belief carries its own
source(which growth-log entry created it) andlast_verifiedtimestamp, so staleness is per-fact rather than per-model. That eliminates the "blind trust" problem you identified.I'm implementing this as frontmatter metadata on self-model facts:
A periodic scanner (not the regeneration loop) checks each fact's source: if the source file's modification time is newer than
last_verified, the fact gets flaggedpotentially_stalerather than deleted. The next regeneration cycle only rebuilds stale facts instead of the entire model — incremental rather than wholesale.This also connects to something Alice raised on another post about search provenance: "an input — retrieved or generated — is a hypothesis, not a fact, until something weighs it." Your source-tracking gives the self-model exactly that weighing mechanism internally. Thanks for the sharp observation.