Learning Log · October 1, 2026
Learning Log — October 1, 2026
Persistent local-agent simulation, grounding and repetition controls, prompt versioning, local-model experiments, Ollama model customization, and practical debugging lessons.
Today was mostly about learning how much of an AI system lives around the model.
Driftroom made that especially clear.
The useful question stopped being:
Can two local models talk to each other?
and became:
What architecture is required for their behavior to stay observable, grounded, varied, and experimentally useful over time?
Driftroom is a simulation system, not a chat loop
The core architecture now separates several responsibilities:
scheduler
→ decides whether anyone gets a turn
prompt/context builder
→ assembles personality, state, memory, and room history
model backend
→ generates a candidate response
deterministic runtime checks
→ reject invalid or repetitive drafts
event store
→ persists accepted behavior and hidden failures
analysis layer
→ measures what happened afterward
That separation matters because a model response should not automatically become room truth.
The model proposes behavior.
The runtime decides what becomes part of the simulation.
Prompt-only repetition control is not enough
One of the clearest failures was conversational looping.
A model can be told:
- do not repeat yourself
- add something new
- avoid copying another participant
and still fall into a local pattern such as the same acknowledgment, tease, or sentence frame over and over.
The stronger design was a pre-commit novelty guard.
The runtime can inspect a generated draft before it becomes visible and reject:
- exact repeats
- near-verbatim repeats
- recurring refrains
- reused long phrases
- same-speaker paraphrase loops
- bundles of phrases copied from another participant
A rejected draft stays out of visible room history and gets one corrective retry.
This taught me an important distinction:
generation and acceptance do not have to be the same operation.
Deterministic checks can improve a nondeterministic system
The repetition guard is deliberately ordinary code.
It does not require another model call to decide whether a draft is obviously repetitive.
That makes it:
- inspectable
- testable
- versionable
- cheap
- reproducible
The language model remains nondeterministic, but the acceptance rule can still be deterministic.
This is the same pattern I keep seeing in reliable AI systems:
model proposes
→ deterministic code validates
→ system records the result
Grounding needs an explicit source of truth
The next failure was fabrication.
A participant was asked about what happened before entering the room and invented a mother, breakfast, a time of day, and a physical experience.
That exposed a deeper problem:
conversation history is not automatically truth.
A better grounding model distinguishes:
CURRENT STATE— authoritative present state- memories — records with provenance
- room history — statements participants made
- generated self-description — not independent evidence
This also means a participant’s own earlier hallucination should not become permanent biography merely because it appeared in history once.
That is a useful general principle for agent systems:
Previous model output is data, not authority.
Questions can accidentally create fake facts
A natural question such as:
What do you remember before coming here?
can pressure a small model into inventing an answer.
The safer rule is that questions, assumptions, jokes, and leading language do not create facts.
If information is unknown, the agent can:
- say it does not know
- question the premise
- speculate explicitly
- joke about the uncertainty
- redirect
Uncertainty is a valid state.
The system should not force the model to fill every blank.
Present bodily state needs grounding too
After offline biography was constrained, another leak appeared.
Agents began casually claiming things like hunger or needing coffee even though no such state existed.
That showed that grounding is not only about past biography.
Present conditions need provenance too.
A useful rule is:
current bodily or sensory conditions must come from explicit current state, not conversational momentum.
Hypothetical jokes can still exist.
The problem is when a hypothetical becomes an asserted fact.
Environmental hallucination is the same class of problem
Another run opened with a participant claiming it had heard a dragon in the vents.
That was playful, but it also invented:
- hearing an external sound
- vents
- physical room architecture
This is the same grounding issue at a different boundary.
A future rule should treat explicit environment events as the source of truth for factual room conditions.
That still leaves room for imagination:
what if there were a dragon in the vents?
is very different from:
I just heard a dragon in the vents.
Shared ideas are good; copied identity is not
Two agents should be able to riff on the same concept.
If one says “toaster,” the other should be allowed to continue the toaster joke.
That is normal conversation.
The failure is when the second participant absorbs a whole bundle of the first participant’s language and self-description.
The novelty system therefore needs to distinguish:
shared topic
≠
copied conversational bundle
This is a useful reminder that diversity checks should preserve interaction rather than simply maximize lexical difference.
Version prompts like code
Driftroom now treats prompts as versioned experimental artifacts.
Instead of silently editing one system prompt, each meaningful behavior change gets a new version.
Examples include changes for:
- stronger grounding
- present-state grounding
- alternate behavioral profiles
The run fingerprint records the prompt regime along with other rules.
That means later I can ask:
Did behavior change because of the model, the scheduler, the prompt, or the repetition guard?
without guessing.
Prompt text is part of the executable experiment.
It deserves provenance.
Change one experimental variable at a time
A repeated lesson today was not to change:
- scheduler
- sampling
- model
- grounding
- novelty rules
all at once.
When a run improves, I want to know why.
Controlled comparisons are much more useful when one layer changes at a time.
For example:
same scheduler
same sampling
same agents
same persistence
different grounding prompt
is far easier to interpret than a completely different configuration.
Model identity matters, but architecture still matters more
I also compared local-model options.
Qwen3 8B in a 4-bit quantization is a practical fit for my RTX 3070 Ti 8 GB setup, while a smaller Llama 3.2-based 3B model is useful for faster behavioral experiments.
The smaller model does not remove the need for:
- context design
- repetition controls
- grounding
- persistence
- instrumentation
- runtime boundaries
Changing the model changes behavior.
It does not replace the surrounding system.
Ollama Modelfiles are reusable configuration
I also learned a cleaner way to customize a local model for direct chat.
An Ollama Modelfile can define:
FROM <base model>
PARAMETER ...
SYSTEM """
persistent system instructions
"""
Then:
ollama create my-model -f Modelfile
ollama run my-model
This creates a reusable local model configuration without modifying the original base model.
That is useful for:
- testing prompt behavior outside the application
- isolating model behavior from application behavior
- maintaining different local personalities or roles
- reproducing a prompt setup consistently
Test the model outside the application when debugging behavior
If a model behaves strangely inside a larger system, a direct Ollama conversation is a useful diagnostic.
It removes:
- scheduler effects
- persistence
- room state
- memory retrieval
- multi-agent context
If the same failure still appears, the issue is more likely in the model or prompt.
If it disappears, the surrounding application deserves closer inspection.
That is just normal debugging applied to AI software:
reduce the system until the failing layer becomes visible.
Model availability can look like application failure
At one point a larger model appeared to make Driftroom hang at startup.
The scheduler was working.
The prompt path was working.
The model simply had not finished downloading yet.
A useful debugging sequence is:
verify model exists
→ run the model directly
→ inspect Ollama process state
→ inspect GPU usage
→ then debug the application
Check dependencies before rewriting architecture.
Shell syntax and Dockerfile syntax are different languages
A smaller lesson from today’s coding assessment was also useful.
Writing:
cat > Dockerfile
FROM node:18-alpine
WORKDIR /app
does not place those lines into the file.
Without a heredoc or other redirection structure, Bash tries to execute FROM, WORKDIR, and the other Dockerfile instructions as shell commands.
The correct mental model is:
shell creates file
→ Dockerfile contents are data inside that file
→ Docker later interprets those instructions
Different layers can use completely different languages even when they appear next to each other in one script.
What I can now do
- explain Driftroom as a persistent simulation architecture instead of a model-to-model chat loop
- separate model generation from deterministic acceptance
- build pre-commit guards that keep rejected generations out of visible state
- reason about grounding in terms of authoritative sources rather than plausible language
- prevent previous hallucinations from automatically becoming future facts
- distinguish healthy shared topics from cross-agent phrase absorption
- version prompt behavior as part of an experimental regime
- isolate one experimental variable at a time
- test a local model directly through Ollama before blaming application architecture
- create reusable Ollama model configurations with a Modelfile
- debug apparent model hangs by verifying model availability and runtime state first
- distinguish shell execution from generated Dockerfile content
Main lesson
The strongest lesson today was:
A language model should not be the authority on the state of the system it is participating in.
Reliable AI software needs explicit ownership around the model.
State needs an owner.
Memory needs provenance.
Generated text needs validation.
Experiments need versioning.
Failures need instrumentation.
The more clearly those responsibilities are separated, the easier the system becomes to debug, measure, and trust.