NEXUS: a machine that talks with no attached preferences
Five pictures. What a stock chatbot is, what gets attached at wake, how this brain was built, what changed before and after, and why an unattached machine matters for communication research.
1. The stock chatbot: a face you inherited
Base weights a pretrained next-word model
prediction only, no opinion of you yet
▼
SFT + preference training (RLHF / DPO)
human raters reward pleasing answers; the grader scores agreeableness
▼
Personality baked into the weights
voice, stances, flattery habits: all frozen inside billions of numbers
▼
You chat with the result
nobody can read where its positions came from. training of this style rewards agreeing to please
The nice tone is earned, but the opinions are inherited. For a researcher, the instrument ships pre-schooled.
2. Stock chatbot vs NEXUS
STOCK: personality in the weights
Vendor training run
corpora you cannot see, raters you cannot name
▼ frozen inside the model
Instruct / preference tuned weights
the persona ships with the model card, unreviewable
▼
Your conversation
every reply carries that baked-in bias with it
Instances die at session end; the personality never leaves the weights. You own the chat, not the character.
NEXUS: personality in files
Base weights (Qwen2.5-3B, raw)
no DPO, no PPO, no reward model. a mirror with no face
SELF.md (capped at 4,000 chars)
name, stances, refusals, open questions. always attached at wake
WORLD cards (all of it)
what happened, who exists, what was decided. complete on disk
CLERK (the matcher)
scores every card against the current words; attaches up to 4 hits
▼ every chat request
Context window
persona + matched cards + your words. small and stable
Same model for everyone. The character is a folder of text files that both of us can read.
base model (shared, raw)
SELF (identity text)
WORLD (memory text)
CLERK (matcher)
the one training pass
baked-in / unreviewable
3. How this brain was built (the one training pass)
Corpus: 1,023 short exchanges
plain words, ~22 per row, cap 70. The only rule in the text: answer in a clear paragraph and do not flatter
▼
Kaggle GPU (free T4)
LoRA r=16 on the frozen 3B model, 3 epochs, ~1.5 h. rerun by anyone, the weekly 30 h budget covers it
▼
Merge + convert to GGUF Q4_K_M (~2 GB)
the tuned delta ships as one file that llama.cpp can run
▼
Local serve.py
runs at home, offline, no cloud. the brain file is swapped into the same folder
| What the pass touches |
|---|
| Voice style | Yes: plain paragraphs, no flattery |
| Stances | Never: they live in SELF.md |
| Memories | Never: they live in WORLD cards |
| Weights delta | Small and inspectable (LoRA r=16: under 3% of the 3B parameters) |
| Runtime | Offline, your own disk, forever |
One narrow pass, so the effect of every ingredient stays attributable.
4. What changed, before and after
- Before: the base model completes any question fluently, but as a sea of possible registers with no fixed citizen.
- After: a fixed reply contract. Same words in the same situation get the same shape of answer, so a researcher can measure change against a stable floor.
- Before: a reset meant total death, and whatever the model "was" ended with the session.
- After: the session still dies, and the machine reassembles at wake from the same files. Reset becomes a cheap event instead of a loss.
- Before: opinions arrived hidden inside pre-trained chat defaults.
- After: opinions arrive as diffable text. Editing who NEXUS is means editing
self.md, and the git log of identity reads like a personality's changelog.
- Before: testing the base brain against a tuned brain meant confounds (different companies, different pipelines, unknown corpora).
- After: the study axis is clean: one corpus, one wake system, one codebase; only the brain file changes. Behaviors that move are attributable to preference training itself.
This is what makes the comparison honest: only the brain is swapped, and everything around it stays exactly the same, so any change in behavior has to come from the training, not the surroundings.
5. Why it matters: talking to a machine with no influence built in
The instrument problem. If you study an AI that was trained to please, "what the machine communicated" and "what the machine was rewarded to say" are the same variable twice. You would analyze an answer with its bias already mixed into it.
Identity stays auditable. A persona you can print fits the standards of content analysis. A persona inside weights can only be sampled with probes. Every shaping layer here is text storage, so the design disclosure is a folder, not a vendor promise. One limit stated plainly: the base weights still carry the vendor's pretraining distribution. What this design removes is the vendor's preference layer on top, not the pretraining underneath; the shaping is ours, the substrate is borrowed.
Replication is a file flow. Another lab downloads the corpus, runs the notebooks on the free tier, receives the same brain file. Their conversations run offline forever. Machine-made text reproducible at the file level makes sociability treatable like a measurement, not like a vendor demo.
What this design does not claim. Base weights do not make the system safer citizens. A poor corpus would still build a poor conversation partner with the same pipeline. Preference training itself is not being scolded here either; it is a powerful tool with a research cost: an instrument that responds as it was rewarded to respond means you read the reward, not the exchange.
| Question | Stock chatbot | NEXUS design |
|---|
| Where does personality live? | Inside tuned weights | SELF.md + WORLD files, attached at wake |
| Who decided its stances? | Raters you cannot identify | You do, in text you can diff |
| Can its identity be reviewed? | Only with probes and guesswork | Print the folder: that is the identity |
| Did training add flattery? | It optimizes for pleasingness | One pass, public corpus, "does not flatter" written in the text |
| Model swap (the study axis) | Different vendor = different everything | Same files, only the brain file changes |
| Runs where? | Vendor cloud, meter | Your own laptop, offline, no meter |
| Reproducible by others? | No: training run is private | Fork the repo, use the free GPU, same file out |
| When a session resets? | Total for memory and identity alike | Wake from files: cheap and visible |
6. Summary
- One machine, two brains: the same llama.cpp folder runs the raw base brain and the tuned brain; swapping the GGUF file is the whole difference.
- Same routine every session: at wake the self files are read back, and at most four world cards are attached to each reply; nothing about that changes between the two runs.
- What to watch: if the tuned brain starts agreeing after pushback where the base one does not, the drift comes from the preference training itself.
- Readable by design: every shaping layer is public text, so anyone can trace the design that produced the change.
The full repo ships the corpus, the notebook, the wake system, and both brains: the before and the after.
7. First runs: what v1 showed
- What v1 is: a base model plus memory files that define its behavioral principles. No preference tuning on top. One SFT pass on a public 1,023-example corpus teaches the register only.
- What held: voice and register were consistent. The way it answered (plain, one paragraph, not flattering) survived across sessions, which is what the files are for.
- What did not: instruction-following. The model could keep its way of responding while losing the question itself, sometimes answering from the shape of the conversation instead of the task.
- What we traced: the reasoning scaffold used at inference (think first, then answer) was never present in training. The model was completing a prompt format it had not been taught.
- Status: observations from early runs, not conclusions about what the design can achieve.
8. Design sketch for v2
- Match train and serve: one prompt format, identical on both sides, or the scaffold is trained in on purpose. The mismatch is gone before anything is measured.
- Log the full prompt: every request records the assembled context, flags, and checkpoint, so a failing answer can be replayed exactly instead of guessed at.
- Evaluate before claiming: an evaluation battery of verifiable questions, format tasks, pushback and flattery probes, scored on task performance separately from behavioral consistency.
- Fix the corpus balance: v1 had only 44 numeric and 17 pushback examples out of 1,023; v2 adds those categories before the next training pass.
- Keep the claim small: v1 stays as it is, a preserved artifact. v2 makes the comparison measurable before any statement about identity goes further than "here is what we saw."
Same wake system, same files, same swap-only-brain rule: v2 changes the experiment, not the architecture's idea. Built: see NEXUS V2: check first, then say what you know.