Calling the algorithm unbiological is the easy part. The hard part comes next: how does a brain spread one word — "wrong" — across millions of synapses?
Fall off a bike and you don't go home and retrain every muscle in your body — you roughly know it was the way you leaned on the handlebars. That sounds trivial, and it is the hardest problem in learning: the outcome hands you a single "wrong", while the parts that produced it number in the millions, and each needs its own correction in its own direction. AI has one startlingly effective answer, the one every model that chats or draws today is built on. Neuroscience has been saying since 1989 that neurons cannot possibly run it. This issue is about that unfinished argument — and about a more interesting turn in it: rather than asking whether the brain does this, ask what parts it uses to accomplish the same thing.
The algorithm itself is no mystery. Picture a long assembly line where every station nudges the workpiece a little, and the finished item comes out three millimetres off spec. Whose fault? From the result alone, nobody knows. But you can walk backwards, asking the last station: if you had pressed a touch less, how much smaller would the final error be? Take that number to the station before it, and keep walking back. Now every station holds its own share of the bill: which way to move, and how much. Everyone shifts a little, and the next item comes out closer. That is backpropagation, and essentially every AI that learns anything uses it to turn hundreds of billions of knobs.
The trouble is entirely in that backwards step. To work out the previous station's share, you need how hard each station pressed on the way forward. In a computer that's nothing: those numbers sit in memory anyone can read, and the backward pass simply looks them up. A brain isn't built that way. In 1989 Crick laid the problem out, and the field has been arguing from that page ever since:
First thorn: the way back doesn't know the way out. Synapses are one-way; signal flows only from sender to receiver. A backward pass needs its own descending synapses. But for the shares to come out right, those return synapses would have to be exactly as strong as the forward ones — and how would one synapse ever know how strong another synapse currently is? This is the weight-transport problem, the sharpest of the four.
Second: the brain never pauses. The algorithm wants the forward pass finished, then a backward sweep from the far end, with nothing changing in between. The brain runs without stopping: sensation keeps arriving, movement keeps leaving, and there is no pause button.
Third: the error has to be an exact number. What travels backwards is signed and continuous, and it has to reach each individual synapse. Neurons only ever "fire a spike" — all or none (Topic 35 covered that alphabet).
Fourth, and most basic: a synapse is blind. It senses only the two cells it sits between. It cannot see the outcome several layers away, let alone how far off the whole system was (Synaptic plasticity). Backpropagation asks it to change according to a global quantity arriving from somewhere far off.
Stack the four and the verdict sounds firm: backpropagation needs global information, exact symmetry, and a network that stops to synchronise, while the brain's parts are local, one-way, and always running. For thirty years, "that algorithm isn't biological" was the default position.
None of the four objections bites in AI, for a mundane reason: a chip has memory everybody can read. The forward weights sit right there to be looked up on the way back, and the network can happily run "compute forward, then propagate back" because it is a program executing step by step to begin with. The brain has no such shared memory — its memory is the synapses, scattered across millions of places, none of them readable by anyone else. A surprising number of "why doesn't biology just do it this way" questions bottom out in that hardware difference.
A 2016 result scrambled the whole argument. Lillicrap's group did something that looks like a prank: if the return path can't know the forward strengths, then let it not know — replace the backward weights with a pile of random numbers, fixed once and never updated again. By rights, assigning blame through gibberish should point every correction in the wrong direction. The networks learned anyway, and nearly as well as with real backpropagation.
Why? Because the gibberish, though random, is consistent. The forward weights are the ones that change, and over training they drift towards the configuration that makes that fixed random feedback useful — after a while the forward weights genuinely line up with the random matrix, the angle between them shrinking from around ninety degrees. The feedback never becomes correct; the forward pathway learns to cooperate with it. The effect is called feedback alignment.
Half of the sharpest thorn is gone: the backward weights need not equal the forward ones — as long as they are stable and consistent, the network will come to them. Nøkland went further the same year, projecting the error from the output straight into every layer at random, dispensing with the layer-by-layer walk entirely, and it still learns.
Don't celebrate too early. In 2018 Bartunov and colleagues pitted these biological variants against hard problems (ImageNet-scale data, convolutional architectures) and the gap showed immediately: working on small datasets is not the same as holding up in genuinely deep networks. "Random feedback can learn" is a lovely existence proof, not a sufficient answer.
Backpropagation has another irritating property: each layer has to wait for the layer before it to finish its share of the bill, which makes the whole network awkward to parallelise. Random feedback cuts that chain — the error goes straight to every layer, and layers can update at once. That is why these algorithms keep resurfacing in on-chip learning (chips that learn while they run, without shipping data back to a central processor) and similar directions. Biology's constraints often turn out to be the hardware's constraints too.
The other route is more radical: abolish the backward pass. If a synapse can only see its own two ends, then make the error part of what those two ends are doing — no separate error wiring, just cells whose activity looks different depending on whether there is an error, so that a synapse changing by its usual local rule happens to move in roughly the right direction. Three versions, same skeleton, different parts.
One: predictive coding. Neuroscience already had this model (Topic 1): higher levels send predictions down, lower levels report only what wasn't predicted, and the network already contains units whose job is to represent error. Whittington and Bogacz showed in 2017 that if you let such a network relax to equilibrium and then let every synapse change by the product of its two ends' activity (fire together, wire together — the classic local rule), what it learns approximates backpropagation. The error never travels backwards; it was living in the network all along.
Two: equilibrium propagation. Scellier and Bengio take a different angle: let the network settle freely and remember that state, then nudge the output gently towards the right answer and let it settle again. The difference between the two steady states encodes the gradient. All a synapse has to notice is how its own two ends differed between the two settlings — which is very close to what synaptic plasticity actually looks like in experiments (Synaptic plasticity).
Three: hand the error to anatomy. A cortical pyramidal neuron has two ends: basal dendrites near the cell body take feedforward input from below, while one long apical dendrite reaches the cortical surface and receives feedback sent back from higher areas (Cortical layers & microcircuit). The two streams land on different parts of the same cell, so they don't collide. Guerguiev and colleagues built networks from such compartmentalised neurons in 2017 and taught them handwritten digits; Payeur and colleagues in 2021 tied the idea to a real physiological mechanism: when the apical dendrite is driven, the cell doesn't fire once, it fires a burst. Downstream cells read "a burst" and "a single spike" as two different messages — so one axon carries both the signal and how wrong the answer was.
The three routes look unalike, but the skeleton is one: the error stops being separate wiring and gets folded into the activity itself — hidden in dedicated error units, in the difference between two steady states, in burst versus single spike. Lillicrap and colleagues put it plainly in their 2020 review: if the brain does gradients at all, this is most likely how.
At this point it's worth stepping back: does the brain even need to do this? Backpropagation solves fine-grained credit assignment across many layers. But the brain may not be one big network trained end to end at all. Marblestone and colleagues sketched a very different picture in 2016: more like a pile of modules each with its own objective — what visual cortex optimises, what motor cortex optimises and what hippocampus optimises are simply not the same thing, and many of those objectives are written by development, or set by the system for itself ("predict what you'll see a second from now" needs no teacher). If no module is deep, the distance blame has to travel is short, and the sharpest thorn stops hurting.
One impression worth correcting along the way: learning from error is not exotic in biology. The cerebellum plainly has a teaching line — every Purkinje cell receives a climbing fibre that fires when a movement goes wrong, and synapses change directly (Motor system & cerebellum). So the real dispute was never whether brains use error signals, but whether cortex performs that fine-grained, synapse-by-synapse assignment across many layers.
And there is one stubborn fact pointing the other way. The best current models of visual cortical responses happen to be deep networks trained with backpropagation: show a monkey and a network the same image, and the network's intermediate layers predict inferotemporal responses rather well. That does not show the brain uses backpropagation. It says something else — what a representation ends up looking like may be set mostly by the task and the architecture, not by the learning rule.
So the shape of the argument has changed. Rather than asking whether the brain does backpropagation (which welds an algorithm to one silicon implementation of it), treat it as a yardstick: any system that learns well through deep structure has to approximately accomplish something, so go back to the brain and ask what parts might accomplish it. The advantage is that it lands on a lab bench — when exactly the apical dendrite is driven, whether learning collapses once feedback pathways are cut, whether bursting really is yoked to synaptic change: all measurable. An argument that yields testable predictions has already paid for itself.
The argument is feeding back into AI. Backpropagation's three demands — shared memory, a global pause, every layer waiting on the one before — are no longer only a biologist's complaint; they are an energy bill. The electricity behind training a large model and the twenty watts inside your head (Topic 41 does that arithmetic) differ by orders of magnitude. Hence renewed interest in chips built around local rules and event-driven activity (Topic 40). Constraints once dismissed as biological quirks are now the homework engineers want to copy.
"How does a global optimum get built out of parts that can only see their neighbours?" — the question isn't neuroscience's private property; several distant fields have walked into it: