Is Memory the Individual?

In Post 2, I destroyed the substrate and watched what came back. A skill learned through plasticity died with the brain that held it. But an external memory, handed to a fresh brain that had never trained, reinstated the behavior anyway. Experience turned out to be separable from the specific hardware that recorded it.

That was impressive, but it was tame. It was still my memory going back into a copy of my kind of brain. It confirmed that memory is portable. It did not touch the harder question: what happens when the memory and the brain disagree about who they belong to? If I keep the brain identical and swap the memory, does the individual follow the biology or the story?

I ran it. The result was not confusion. It was closer to possession.

To isolate the question I needed a clean room: no architectural differences, no sensory drift. Two individuals, identical down to the wire. The same connectome architecture, the same wiring recipe. They see the exact same cues in the same world. The only thing that differs is their answer key, what counts as the correct action for each cue.

In world A, a given cue calls for one action. In world B, that same cue calls for a different one. These are not different strategies, they are different realities. Through experience the two become different individuals, their behavior diverging completely, while their hardware stays identical. That removes weight-individuality as a confound. If anything travels between them, it can only be the memory graph.

Here is the actual setup. Two worlds share their cues and conflict only on the answer key. Then I take one pristine, never-trained brain, clone it so both conditions run on the exact same weights, and score the copy twice in world A: once carrying world A's memory, once carrying world B's.

# two individuals: identical connectome architecture, SAME sensory world,
# CONFLICTING answer keys. The only thing that differs is what they learned.
world_A = Gauntlet()
world_B = Gauntlet(mapping=(world_A.mapping + 1) % world_A.n_actions,
                   cue_patterns=world_A.cue_patterns)

_, mem_A, _ = run_condition("indivA", world_A, use_mem=True)
_, mem_B, _ = run_condition("indivB", world_B, use_mem=True)

# ONE pristine substrate, cloned so BOTH conditions run on the EXACT same
# brain (weight-identical, not just same-seeded). The only variable that
# changes between the two scores is which memory graph is attached.
pristine = Connectome(world_A.cue_dim, n_actions=world_A.n_actions)
fresh1, fresh2 = pristine.clone(), pristine.clone()

# score the same brain in world_A, once with its "own" memory, once swapped
own  = evaluate(world_A, fresh1, mem_A.clone())
swap = evaluate(world_A, fresh2, mem_B.clone())

That clone is the whole ballgame. If those two brains were merely built from the same seed rather than copied weight for weight, a technical reader would be right to ask whether a substrate difference was doing the work. So I made the substrate literally the same object, copied, and let only the memory vary.

Before the numbers, the rule of the road. The metric is accuracy on the cue task: the fraction of trials the agent picks the correct action, from 0.0 to 1.0. With 3 actions, chance is 0.33.

Above 0.33, something is helping. Around 0.33, nothing is. Below 0.33, something is actively steering the agent wrong.

Below chance is not failure. It is being reliably steered toward someone else's answers.

Here is what happened when the memory and the brain disagreed.

Accuracy is the fraction of trials the agent picks the correct action, 0 to 1. Chance is 0.33.

Own memory in its own world: ~0.97. A brain that never trained the task basically solves it. The memory simply worked.

Conflicting memory: ~0.17. That number is the pivot of the whole experiment, and it is below chance.

Do not read 0.17 as noise or as ordinary failure. Chance is what you get from knowing nothing. Below chance means the agent is being pushed, reliably, toward wrong answers. Specifically toward the answers of the other individual, because in world B those were the right answers.

The conflicting memory did not confuse the brain or scramble its processing. It ran the brain as the individual it belonged to. The graph held the behavioral signature, strong enough to override the fact that the brain was sitting in a different reality.

Identical brains produced opposite behavior. The only thing that differed was the memory. So where was the individual? Not obviously in the weights, those were the same. It looks like it rode in the graph.

I am not claiming memory is the self. That is a slogan, and these numbers do not support slogans. I am reporting something smaller and stranger: under these controlled conditions, the behavioral difference I induced through experience tracked the memory rather than the substrate. When the two disagreed, the memory won. That is the claim the data actually supports.

What this shows is narrow and precise: with the substrate held identical, the learned behavioral signature traveled with the memory into a blank brain, strongly enough that a conflicting memory drove that brain below chance toward its original owner's answers.

What it does not show is broad. It does not show transfer across different architectures. The shared connectome is exactly what makes the result clean, and exactly why it is not yet a portability proof. It says nothing about consciousness or selfhood in the felt sense, which is off the table, unfalsifiable, and not a knob. It does not use a real connectome, real embodiment, or more than one seed. The shared brain is the control condition and the ceiling on the claim, in the same breath.

There is a darker reading, and it points straight at Post 4.

If a behavioral individual can be written into a blank brain by handing it a memory graph, and a conflicting graph can drive that brain below chance toward someone else's answers, then the memory is not just storage. It is a control surface. Whoever can write the graph can potentially write part of the agent's behavioral history.

And a graph can be authored. Nothing in the mechanism checks whether a memory was lived or fabricated. The missing primitive is provenance of experience: telling a memory that was earned through interaction from one that was simply written in.

That is Post 4: your agent's memory is an attack surface.

Clone it and break it.

git clone https://github.com/constant-itis/flymem && cd flymem && python3 flymem.py