Fly Language Model Wires a Fruit Fly Brain Into an LLM. The Graph Doesn’t Help.

A developer has published the Fly Language Model (FLM), a system that grafts the entire retained male fruit fly brain connectome (166,700 neurons, 25.5 million directed synaptic connections) onto a frozen LiquidAI LFM2.5-1.2B-Instruct language model. Only a tiny 278,528-parameter readout layer is trained. The headline result: the fly wiring did produce a small improvement over the bare frozen backbone. The inconvenient result: a control with no graph at all performed better in every single test seed.

What happened

Detail	Value
Backbone model	LiquidAI LFM2.5-1.2B-Instruct (frozen)
Connectome source	MaleCNS v1.0 (full retained graph)
Graph nodes	166,700
Graph edges	25,582,938 directed
Backbone parameters	1,170,340,608 (all frozen)
Trained parameters	278,528 (approx. 0.024% of backbone)
Evaluation set	32 SmolTalk dialogues, 1,236 target tokens
License	MIT, runs on Python 3.12, no API key needed

The FLM is what researchers call a reservoir computer. The connectome acts as a fixed dynamical system: its weights are never updated. At each token, a frozen Gaussian projection compresses the language model’s 2,048-dimensional embedding down to 128 channels. Each neuron in the fly graph receives one channel with a random sign, then the whole network updates using the formula x = tanh(W(0.6x + 0.4Bc)), where W holds anatomical contact counts normalized by incoming connections. The resulting states are pooled into 128 bins and passed through two small trained matrices before being added back as a bounded residual on the backbone’s output logits. That residual is capped so its RMS never exceeds 0.25.

The only part that learns is the readout: two bias-free matrices (U at 128×128, V at 2,048×128). Everything else, the graph, the backbone, the input and output projections, stays frozen throughout training.

What do the numbers actually show?

The evaluation used three random fit seeds on a held-out set. Here is how every condition compared on negative log-likelihood (NLL), measured in nats per token. Lower is better.

Condition	NLL (nats/token)
Frozen backbone (no readout)	1.381995
Fly readout (connectome active)	1.359816 ± 0.000110
Direct-input readout (no graph)	1.359328 ± 0.000108
Relabeled nodes, no refit	1.381265 ± 0.000802
No edges (W = 0)	1.381995

The fly readout beat the frozen backbone by 0.0222 nats per token, which corresponds to a perplexity drop from 3.98 to 3.90. That sounds like progress. But the direct-input control, identical readout architecture with the fly graph simply removed, outperformed it in all three seeds by 0.000488 nats per token. A paired bootstrap confidence interval on that gap runs from +0.00000502 to +0.00104, which means the data do not support any fly-specific advantage.

Two other controls tell an important story. Setting W to zero removes the residual entirely and exactly reproduces the backbone’s per-token losses, which confirms the graph is genuinely participating in computation. Relabeling which neuron is which, without retraining, breaks the improvement and returns NLL near baseline. So the readout has learned to interface with a specific wiring pattern, but that wiring pattern does not need to be a fly brain to work as well or better.

Why long memory is not on the table

The paper proves mathematically that state differences contract by at most a factor of 0.6 per token. After 10 tokens, the maximum difference between two starting states is 0.00605. After 20 tokens it is 0.0000366. The reservoir forgets almost everything quickly. Any long-range context in responses comes from the frozen backbone’s own attention mechanism, not the connectome.

Why it matters

This project is a careful, honest piece of negative-result research, which is rarer than it should be. The developer explicitly notes that an earlier project, ngxson/fly-hf, used a 49,393-cell central-brain subset of the same connectome as a reservoir trained on TinyStories without a pretrained backbone. FLM’s contribution is scale (the full retained graph) and a cleaner experimental design that keeps the language competence attributable to the backbone. Importantly, the developer does not oversell: the paper acknowledges the graph does not win, and the controls are reported alongside the main result rather than buried.

For practitioners watching the broader trend of neuroscience-inspired AI, this is a data point worth filing. Plugging a biological wiring diagram into a capable LLM as a frozen reservoir does not appear to add language performance, at least not at this scale and with this training budget. The gains visible in the headline number disappear under a simple ablation.

For anyone following AI research more broadly, this connects to the wider question of whether biologically plausible architectures offer practical gains over purely learned systems. Right now, the answer here is no. You can read more coverage of similar architecture experiments in our AI news archive.

Our take

Credit where it is due: publishing your own controls that contradict your headline finding takes integrity. Most ML demos would quietly drop the no-graph ablation or bury it in an appendix.

That said, the result is not surprising. A reservoir computer, biological or not, is fundamentally a fixed random projection with dynamics. The readout can only learn to exploit whatever structure the frozen graph creates. With a 0.6-per-token contraction rate, the connectome is essentially a stateless feature scrambler. The backbone’s context window does all the heavy lifting.

The more interesting question the paper raises but does not answer is whether a trained (not frozen) connectome-structured network could add something. The current design makes that impossible to test because the graph never updates. Until someone runs that experiment with a matched trainable baseline, the neuroscience-to-LLM transfer story remains more aesthetic than functional.

If you are thinking about integrating unusual architectures or external signal sources into your own AI workflows, our AI integration work is grounded in what actually ships and performs, not what looks interesting on a diagram.

What to do about it

1. Try the repo yourself: nftechie/flm is MIT-licensed, needs no API key, and runs on Python 3.12 with CPU, MPS, or CUDA.
2. Run the no-graph control first before attributing any performance change to the connectome component.
3. Wait for study artifacts to be published before citing numerical results in your own work. The paper states they are not yet public.
4. Watch for follow-up work that trains (rather than freezes) the graph weights. That is the real experiment this paper sets up.

The practical takeaway: when a novel architecture beats a frozen baseline but loses to a simple ablation, the architecture is doing less than it appears.

Source: Marktechpost