Invented scenario Everything in this story is invented. It is here to give intuition, never evidence.

It is Ugadi, the new year, and the Bhat family has gathered at the grandfather's house in Mysuru. Lunch is on banana leaves. Before anyone eats, each person takes a pinch of bevu-bella, neem and jaggery mixed together, bitter and sweet in one mouthful.

Vikram Bhat builds software agents for a start-up in Bengaluru. His newest system chains four calls to a language model: one drafts a reply to a customer, one checks the facts, one fixes the tone, and one formats the result. When a customer complains, a fifth call writes a critique. That critique is passed back along the chain, and each step rewrites its own instructions in the light of it.

"It is backpropagation," he says, "with words instead of numbers. The paper even calls them textual gradients."

His sister Priya is a neuroscientist. Her laboratory asks whether the cortex learns by something like backpropagation. "Then you have solved a problem my field has argued about for forty years," she says. "Every textbook says the brain cannot do backprop. The errors would have to travel backwards along the same connections, with the same strengths. Neurons do not work like that."

Their grandfather, Shankara Bhat, taught Sanskrit for thirty years. He has been listening while he eats. "In Mīmāṃsā," he says, "a great sacrifice has dozens of small acts. The fruit comes years later, perhaps in another life. So each act leaves an unseen trace, and the traces are gathered into one. Nobody needs to remember which ladle was poured when."

Three people, three systems, and one word between them. Each is talking about credit assignment: when a result is good or bad, how much of the credit or blame belongs to each step that led to it. Vikram claims his agents do it the way neural networks do. Priya doubts that brains can. Shankara describes a tradition that answered a version of the question long before either field existed.

The question for this paper is exact. What information does backpropagation require, and which proposed biological or agent-level analogies preserve those requirements?

Here is the answer in plain words, before the argument. Backpropagation is the chain rule of calculus run backwards through a graph of computations. Derived carefully, it is local: each node needs only its own stored input, its own local derivative, and a signed error arriving from the nodes it feeds. Nothing in the method needs a central accountant. The hard part is the backward channel. The error each node receives must be a vector of signed numbers, one per unit, and it must have passed through the same connection strengths that the forward signal used.

I tested which of these requirements matter by removing them one at a time from a small network. Replacing the exact backward weights with fixed random ones barely hurt. Replacing the per-unit error with one shared score made learning between nine and thirty times worse. Using stored activity from the wrong input stopped learning entirely. So the requirements are not equal, and an analogy should be judged by which ones it keeps.

By that test, some biological proposals keep almost everything that matters, and the textual gradients in Vikram's agents keep the graph and the order but drop the derivatives. Textual gradients are credit assignment by critique, not by derivative. They may still work. They do not inherit backpropagation's guarantees.

[AUTHOR NOTE: if you have built or debugged a pipeline of model calls where feedback was passed backwards, two or three sentences on what went wrong, and how you found which step to blame, would ground this scene.]

The paper builds the case in steps. Part 1 derives backpropagation from the chain rule and lists exactly what each node needs. Part 2 asks why biologists think the brain cannot supply those needs, and runs the instrument that removes them one at a time. Part 3 looks at the simplest alternative, learning from one shared score, and measures how badly it scales. Part 4 sorts the biological proposals by which requirements they keep. Part 5 tests Vikram's claim about agents. Part 6 asks what the Mīmāṃsā doctrine of apūrva, the unseen trace, can and cannot teach about credit passed through a graph.

Start with a definition that has no neurons in it. A computation graph is a set of steps, each of which takes some numbers in and passes a number out. The steps are connected so that the output of one becomes an input to another. At the end sits one number we care about, the loss, which measures how wrong the whole computation was.

Credit assignment asks a simple question about this graph. If I nudged one number somewhere inside, how much would the loss change? That rate of change is the derivative of the loss with respect to that number. If we know it for every adjustable number, we know which way to turn each one to make the loss smaller.

The chain rule, one node at a time#

The chain rule says that rates of change multiply along a path. If the loss depends on v, and v depends on u, then the effect of u on the loss is the effect of u on v times the effect of v on the loss. When u reaches the loss by several paths, the effects along each path add up.

Backpropagation, also called reverse-mode differentiation, organises this rule into a two-sweep procedure. In the forward sweep, every node computes its output and keeps a copy of its inputs. In the backward sweep, the nodes are visited in reverse order. Each node receives one number from downstream, called its adjoint: the derivative of the loss with respect to that node's output.

The node then does one local job. It multiplies the adjoint by its own local derivative, the rate at which its output changes with each input, evaluated at the stored inputs. It passes each product back to the node that supplied that input. Where a node feeds several others, the adjoints arriving from each are summed.

That is all. No node ever needs to know the shape of the whole graph. It needs the adjoint arriving from its consumers, the inputs it saw on the way forward, and the formula for its own local derivative. In that sense backpropagation is a local method, and its locality is the reason it is cheap.

A minimal worked case: blame for a small sum#

Take the expression f = (a × b + c)², with a = 2, b = −3 and c = 10. Break it into three nodes. The first computes u = a × b = −6. The second computes v = u + c = 4. The third computes f = v² = 16. The forward sweep stores each input as it goes.

The backward sweep starts at the end, where the adjoint of f with respect to itself is 1. The squaring node's local derivative is 2v, which is 8 at the stored value v = 4. So the adjoint of v is 8. The addition node passes its adjoint straight through to both inputs, because adding one to either input adds one to the sum. So u and c each receive 8.

The multiplication node is the interesting one. The local derivative of a × b with respect to a is b, and with respect to b is a. So a receives 8 × −3 = −24, and b receives 8 × 2 = 16. The signs carry meaning: increasing a would decrease f, and increasing b would increase it.

I checked each answer by nudging the inputs by one millionth in each direction and measuring the change in f. The finite-difference estimates were −24.000, 16.000 and 8.000, identical to the backward sweep. The case is small, but it already shows each requirement. The multiplication node needed the stored values of a and b. It needed its local derivative. It needed a signed adjoint. And it had to wait until the squaring node had finished.

Why reverse order is cheap#

There are two ways to apply the chain rule to a graph. Forward mode pushes the effect of one input through to every output. Reverse mode pulls the effect on one output back to every input. When there are millions of adjustable numbers and one loss, reverse mode wins by a vast margin.

Griewank calls this the cheap gradient principle (Griewank 2012; Baydin et al. 2018). The cost of the full gradient of one output is bounded by a small constant times the cost of computing the output itself, however many inputs there are. For polynomial operations, counting multiplications, the constant is exactly three. A naive method that nudges each input in turn costs one extra evaluation per input.

The price of cheapness is memory. Reverse mode needs the stored inputs of every node from the forward sweep, because the local derivatives must be evaluated at those values. Training a large network is often limited by this memory rather than by arithmetic. Hold on to that fact; it becomes a biological problem in Part 2.

What local does and does not mean#

The word local is used in two senses, and the argument about brains often slides between them. In the first sense, a rule is local in space when each node uses only facts held at that node or arriving from its immediate neighbours. Backpropagation passes this test. Every multiplication in the backward sweep uses one stored input, one local slope and one arriving adjoint.

In the second sense, a rule is local in time when each node can act on what it has now, without waiting for anything later. Backpropagation fails this test. A node in the first layer cannot update until every layer above it has finished its backward step. In a network of fifty layers, the first layer waits for forty-nine others.

So when an engineer says backpropagation is local and a biologist says it is not, both can be right. The engineer means space. The biologist usually means time, and the special backward channel that space-locality needs. Keeping the two senses apart is most of what this paper asks for.

A true story: the thesis, the park and the rounding errors#

Who invented backpropagation? The usual answer names Rumelhart, Hinton and Williams, whose 1986 paper in Nature showed that the method taught hidden units of a network to represent useful features (Rumelhart, Hinton and Williams 1986). That paper made the method famous in cognitive science. It did not invent reverse-mode differentiation, and its authors did not claim to.

In 2012 the applied mathematician Andreas Griewank set out to trace the history (Griewank 2012). He found the clearest early statement in a Finnish master's thesis. Seppo Linnainmaa, a student in the first computer science class at the University of Helsinki, completed his thesis on the estimation of rounding errors in 1970.

Linnainmaa wanted to know how the tiny rounding errors in each step of a long calculation affected the final answer. His method traversed the computation graph backwards, computing for each intermediate value the sensitivity of the final result to a small change in it. Those sensitivities are exactly the adjoints of reverse mode. Griewank reports Linnainmaa's own account that the idea came to him on a sunny afternoon in a Copenhagen park.

Linnainmaa published some of the results in English only in 1976 (Linnainmaa 1976). He did not present the method as a cheap way of computing gradients, and, in Griewank's account, it drew little notice until Griewank telephoned him from Argonne in the late 1980s. Others reached the same idea by other roads. Paul Werbos compared forward and reverse propagation for time-dependent problems with neural networks in mind (Werbos 1990). Bernt Speelpenning arrived at it through compiler optimisation.

The lesson of the story is useful here. Reverse mode was found first as a way to track how small errors propagate through a calculation, not as a theory of learning. It is a fact about graphs and derivatives. Whether any brain or agent implements it is a separate question, and the mathematics alone cannot answer it.

The requirements, stated exactly#

Derived this way, backpropagation in a layered network needs five things. I will name them once and use the names throughout.

1. Stored activity (R1). Each unit must keep the input it received on the forward sweep, or recompute it, until its adjoint arrives.
2. Local derivatives (R2). Each unit must apply the derivative of its own response at that stored input.
3. Signed, per-unit errors (R3). Each unit must receive its own adjoint, a number with a sign, not a single score shared by every unit.
4. Weight transport (R4). The adjoint arriving at a unit is a weighted sum of the adjoints of the units it feeds, weighted by the very same connection strengths used on the forward sweep. Grossberg called the need to copy those strengths into a backward pathway the weight transport problem (Grossberg 1987).
5. Ordering (R5). The backward sweep must run after the forward sweep and in reverse order. While it runs, the forward activity it refers to must not be overwritten by new inputs.

None of these needs a central accountant, so backpropagation is local in the sense that matters to engineers. Several are hard for brains, so it is non-local in the sense that matters to biologists. Both statements are true. The argument about whether the brain does backprop is mostly an argument about R3 and R4.

Priya's objection is old, and it has a precise form. A neuron sends its signal forward along its axon to other neurons. The synapses that carry it have strengths that change with learning. Backpropagation asks each neuron to receive, from the neurons it feeds, a signed error weighted by those same synaptic strengths. Axons carry signals one way. So where would the backward signal travel, and how would it know the forward strengths?

A true story: Crick's warning#

In January 1989, a few years after backpropagation became famous, Francis Crick wrote a commentary in Nature titled "The recent excitement about neural networks" (Crick 1989). Crick had shared the Nobel Prize for the structure of DNA and had turned to the brain in the late 1970s. He welcomed the new models as a way of thinking. He doubted that the brain could run their favourite learning method.

His central objection was the one Priya gives. Backpropagation, as usually described, needs information to flow backwards through the same connections, with the same strengths, and he judged that highly unlikely in real neurons. He urged modellers to build networks closer to real brain anatomy. For two decades afterwards, the commentary stood as the standard reason to treat backpropagation as an engineering tool rather than a theory of the brain.

What happened next is instructive. The objection was never answered by showing that axons run backwards. It was answered, in part, by testing whether the requirement was as strict as everyone assumed. That is the strategy of this part of the paper. Rather than ask whether the brain can meet every requirement, ask how much learning is lost when each requirement is removed.

Feedback alignment: the first surprise#

In 2016 Timothy Lillicrap and colleagues published a result that many people found hard to believe (Lillicrap et al. 2016). They replaced the backward weights, the transposed forward strengths that R4 demands, with a fixed random matrix. The errors still flowed backwards and were still signed and per unit. But the strengths they travelled through bore no relation to the forward ones.

The network learned anyway. Lillicrap called the method feedback alignment. The reason it works is subtle. The random feedback sends each hidden unit a consistent, if arbitrary, error signal. The forward weights then change in a way that brings them into rough agreement with the feedback. After a while the random backward path delivers updates that point within ninety degrees of the true gradient, which is enough to go downhill.

Nøkland then showed that the error could be sent directly from the output to every hidden layer through its own random matrix, skipping the layer-by-layer chain entirely (Nøkland 2016). Both results attack R4 directly. They do not touch R1, R2, R3 or R5.

The instrument: remove one requirement at a time#

To find out which requirements matter, I built a small instrument. It trains a network with two hidden layers of 64 units each to copy a fixed teacher network. The teacher maps 20 inputs to 5 outputs through 30 hidden units. The student sees 4,000 training examples and is scored on 1,000 it never saw.

The score is the mean squared error divided by the variance of the target. On this scale a network that always predicts the average target scores about 1. The untrained student scores 1.61, because its random outputs add noise to the average. Lower is better.

The instrument then trains the same student, from the same three starting points, eleven ways. For each I tried five learning rates, from 0.01 to 0.2, and kept the one with the best median. Every number below is the median of three seeds after 3,000 steps of 32 examples each.

The full method. Exact backpropagation reached 0.017.

Remove weight transport (R4). Feedback alignment with fixed random backward weights reached 0.019. This is the first surprise again, reproduced at small scale: the cost of R4 here is almost nothing.

Remove local derivatives (R2). Passing errors backwards without multiplying by each unit's slope reached 0.134, about eight times worse than the full method.

Scramble per-unit errors (R3). Computing the true backward errors and then handing them to the wrong units reached 0.153.

Replace per-unit errors with one shared score (R3). Node perturbation, explained in Part 3, reached 0.151. Weight perturbation reached 0.502.

Keep the size of each error but drop its sign (R3). Every run diverged. The weights moved in one direction until the arithmetic overflowed.

Use stored activity from the wrong input (R1, R5). Pairing each error with the activity from the previous batch instead of the current one reached 3.23, worse than doing nothing.

The negative controls#

An instrument like this needs controls that tell us what failure looks like. I ran three.

Shuffled labels. The student was trained by exact backpropagation on targets shuffled across examples, so that inputs and outputs had no relation. It reached 1.03 on the test set, the score of predicting the average. The learning method was perfect; there was nothing to learn. This sets the ceiling for an update that carries no information about the task.

Random directions. Each update was replaced by a random direction of the same size as the true gradient. The student got worse, reaching 1.88. This is the score of motion without credit.

Readout only. Exact errors were used to train the last layer, and the two hidden layers were frozen at their random starting values. This reached 0.169. It is the most informative control, because it shows what a network gets from credit assignment to the output layer alone.

Set against these controls, the instrument's results change meaning. Full backpropagation and feedback alignment both beat readout-only learning by a factor of nine to ten. Removing local derivatives, scrambling the errors or replacing them with one shared score all landed close to the readout-only control. In other words, those ablations did not slow hidden-layer learning down a little. In 3,000 steps they removed most of its benefit.

The alignment angle#

Feedback alignment can be checked directly. At regular intervals, I computed what the exact gradient would have been and measured the angle between it and the update feedback alignment actually made, for the middle layer of weights.

At the start the angle was 90.5 degrees: the random feedback pointed in a direction unrelated to the true gradient. After 300 steps it had fallen to 56 degrees. From about 1,200 steps onwards it stayed between 40 and 47 degrees. The forward weights had moved to agree with the feedback, exactly as Lillicrap described (Lillicrap et al. 2016).

An angle of 45 degrees means the update captures about 70 per cent of the true gradient's direction. That is why the learning curve for feedback alignment trails the exact method early on and then nearly catches it.

What the instrument cannot show#

The instrument is deliberately small, and its limits should be stated plainly. It uses one task, a smooth mapping copied from a teacher network. It uses two hidden layers. It trains for 3,000 steps, which is long enough to separate the methods but not long enough to say where each would end. A slow method might eventually catch up.

It also tests each requirement in one particular way. There are other ways to remove local derivatives, or to blur the sign, and they might cost more or less. The stale-activity run pairs errors with the previous batch, which is a harsh version of delay. A brain whose activity changes slowly might suffer far less from a short delay.

What the instrument can show is a ranking under fixed, stated conditions, with controls that mark the floor and the ceiling. That is enough to reject the claim that all five requirements are equally essential. It is not enough to fix their costs in a cortex.

A counterexample: where feedback alignment stops working#

The good result in my instrument should not be read as a general one. In 2018, Bartunov and colleagues tested feedback alignment and several other biologically motivated methods on larger image tasks (Bartunov et al. 2018). On the hardest tasks, and in networks with convolutional layers, the methods fell well short of backpropagation.

My network is small, fully connected and learning a smooth target. Those are the conditions in which feedback alignment does best. The cost of removing weight transport is not a constant. It grows with depth, with the structure of the layers and with the difficulty of the task. A requirement that looks cheap in a small network can be expensive in a large one. Part 4 returns to this.

The requirement biologists most often try to drop is R3. Instead of each unit receiving its own signed error, every unit receives the same single number: a global signal saying, in effect, "that was better than expected" or "that was worse". Brains have such signals. Dopamine neurons broadcast something like a prediction error to large areas at once. A learning rule that needs only a broadcast score looks much more like biology.

Perturbation learning#

The simplest way to learn from one score is to try something and see. Weight perturbation adds a small random change to every weight, measures whether the loss went up or down, and keeps the change in proportion to the improvement. Node perturbation does the same thing with small random changes to each unit's activity instead of to each weight.

Both methods are old and well understood. Williams showed in 1992 that a broad family of such rules, including his REINFORCE method, follows the gradient on average (Williams 1992). Each single update is noisy, but the noise averages out. Fiete and Seung proposed in 2006 that a songbird brain area injects exactly this kind of perturbation into the circuits that control song, so that a bird can learn from a single reward-like signal (Fiete and Seung 2006).

The catch is the rate. On average the update points downhill. On any one trial it points almost anywhere, because one score cannot say which of thousands of random changes did the good work. Werfel, Xie and Seung analysed this for simple networks and found that the learning speed of perturbation methods falls as the network grows, while backpropagation's does not (Werfel, Xie and Seung 2005).

A second worked case: measuring how one score scales#

The first worked case in Part 1 checked the derivatives of a tiny expression. This one measures how good a single shared-score update is as the network grows. For networks with hidden layers of 8 to 256 units, I computed the true gradient on one batch. I then made 40 one-shot estimates with each perturbation method and measured the agreement between each estimate and the truth.

Agreement here is the cosine of the angle between the two directions. A value of 1 means the estimate points exactly along the gradient. A value of 0 means it is no better than a random guess.

For weight perturbation, the agreement fell from 0.057 in the smallest network to 0.0024 in the largest. The smallest network had 264 weights and the largest had 71,936. Theory predicts that the agreement should fall roughly as one over the square root of the number of weights. That predicts 0.062 and 0.0037, close to the measured values at every size.

Node perturbation did better, because it perturbs units rather than weights, and there are far fewer units. Its agreement fell from 0.20 to 0.066. It still fell, by a factor of three, as the network grew thirty-fold in units.

These numbers explain the instrument's results in Part 2. With 5,696 weights, a weight-perturbation update agrees with the gradient at about 0.013. It takes thousands of such updates to make the progress of one backpropagation step. Node perturbation, at about 0.13, is ten times better and still far behind.

The general statement is simple. A shared score carries one number of information per trial, however many units need credit. Backpropagation delivers one signed number to every unit on every trial. The gap between them grows with the size of the network, and for a network the size of a cortex it is enormous.

Three factors instead of two#

Biology offers a partial rescue for the shared score. Many synapses appear to change only when three things coincide: activity before the synapse, activity after it, and a third, modulating signal such as dopamine. Learning rules built this way are called three-factor rules.

The first two factors are local and specific to each synapse. They can leave a short-lived mark, an eligibility trace, that records which synapses were recently active together. The third factor is broadcast. When it arrives, only the marked synapses change. Williams's analysis already contains this structure: the update for each weight is the shared score multiplied by a term that only that weight's own activity determines (Williams 1992).

This helps, but it does not change the count. The trace says which synapses took part. It does not say which way each should change to lower the loss. The sign still comes from one shared number. That is why the cosine values above fall with size even for node perturbation, which already uses traces of this kind.

The failure boundary#

When does a shared score suffice? From the measurements and the theory, the answer depends on two things: how many units need credit, and how specific the feedback is.

With few units, a shared score works, slowly. A songbird adjusting a handful of muscles of the syrinx may sit in this corner. With many units and a shared score, learning stalls, as the agreement values above show. With many units and a per-unit signed signal, learning is fast even if the signal is not exact, as feedback alignment shows. The boundary between the stalled corner and the working corner is the line that biological proposals are trying to cross.

Back to the lunch table#

Priya's laboratory, in this invented story, studies how the cortex learns. If her neurons received only a broadcast dopamine signal, the instrument says they would learn hidden features very slowly in any large network. The interesting question for her is therefore narrower than "does the brain do backprop?" It is whether cortical neurons receive a signed signal specific to each neuron, or to small groups of neurons, from somewhere downstream.

That question can be tested. It does not depend on axons running backwards. It depends on whether something in the circuit, perhaps a separate set of feedback connections or a separate part of the neuron, carries a local, signed teaching signal. Part 4 looks at the proposals that say it does.

[AUTHOR NOTE: if you have trained a model with a reinforcement-style reward and watched it learn far more slowly than the same model trained with per-example errors, a short first-person account of the difference would sharpen this section.]

The instrument gives a way to sort the many proposals for how a brain might approximate backpropagation. Do not ask whether a proposal is plausible in general. Ask which of the five requirements it keeps, which it relaxes, and how it pays for the ones it relaxes. Lillicrap and colleagues argued in a 2020 review that most serious proposals share one idea (Lillicrap et al. 2020). Errors are represented as differences in neural activity, so that the backward signal is carried by the same kind of signal as the forward one.

Relaxing weight transport#

Feedback alignment and its direct variant relax R4 and keep everything else (Lillicrap et al. 2016; Nøkland 2016). They need a separate set of feedback connections carrying signed, per-unit errors. Their weak point is scale, as the counterexample in Part 2 showed (Bartunov et al. 2018).

Representing errors as activity#

Predictive coding networks contain two kinds of unit: units that represent a prediction, and units that represent the error between that prediction and what arrives. Whittington and Bogacz showed in 2017 that, when such a network settles, the error units hold values that approximate the backpropagation adjoints (Whittington and Bogacz 2017). The learning rule for each synapse then uses only the activity on either side of it. Millidge and colleagues extended the result to arbitrary computation graphs (Millidge, Tschantz and Buckley 2020).

This keeps R1, R2 and R3, and it replaces R5 with a settling process: the network relaxes for many steps before each weight change. In its original form it still needs symmetric forward and backward weights, so R4 remains, though the backward weights can be learned rather than copied.

Equilibrium propagation, from Scellier and Bengio, takes a different route (Scellier and Bengio 2017). The network settles twice, once freely and once with its outputs nudged slightly towards the target. Each synapse changes in proportion to the difference between the two settled states. The difference plays the part of the signed per-unit error. The two phases are an explicit version of R5.

Putting the error in a different part of the neuron#

Cortical pyramidal neurons have two main receiving zones. Inputs from lower areas arrive near the cell body; feedback from higher areas arrives at the far end of a long apical dendrite. Sacramento and colleagues proposed that the apical dendrite could hold the error, while the cell body carries the forward signal (Sacramento et al. 2018). In their model, local inhibitory neurons cancel the expected feedback, so that what remains in the dendrite is the mismatch.

Payeur and colleagues took the idea further in 2021 (Payeur et al. 2021). They proposed that a neuron can send two messages at once along one axon. The rate of firing events carries the forward signal. The proportion of those events that are bursts, rapid clusters of spikes, carries the error. Since the two codes travel together, the backward signal does not need to wait for the forward one to finish. That relaxes R5 while keeping R3.

Bridging time#

The hardest requirement for recurrent networks, which loop back on themselves, is R1 stretched over time. Exact backpropagation through time would require every neuron to store its whole history until an error arrives. Bellec and colleagues proposed e-prop, in which each synapse keeps a short running trace of its recent activity, called an eligibility trace, and combines it with a learning signal that arrives later (Bellec et al. 2020). The trace stands in for stored activity. The learning signal can be broadcast through random weights, as in feedback alignment.

Dropping the backward pass#

Two more radical proposals drop the backward sweep. Synthetic gradients train a small side-network to predict each layer's error before the true one arrives, so that layers can update without waiting (Jaderberg et al. 2016). Hinton's forward-forward algorithm replaces the backward pass with two forward passes, one on real data and one on contrived negative data, and lets each layer improve a local measure of its own (Hinton 2022). Both relax R5 heavily. Neither yet matches backpropagation on hard tasks.

A summary in one line#

The proposals that keep a signed, per-unit error, by whatever route, are the ones that come close to backpropagation's performance. The proposals that drop it, or drop the record it refers to, fall back towards the readout-only control. The per-unit signed error is the requirement that carries the most weight, and weight transport the least. The instrument found the same ordering at small scale.

Vikram's claim is now testable. His pipeline is built with a framework like TextGrad, which Yuksekgonul and colleagues introduced in 2024 and published in Nature in 2025 (Yuksekgonul et al. 2024; Yuksekgonul et al. 2025). TextGrad treats a compound system of language-model calls as a computation graph. The variables are pieces of text, such as prompts, drafts or code. A final evaluation, written by a language model, plays the part of the loss.

The framework then works backwards. For each step, a language model is asked to write criticism of that step's output in the light of the criticism of the steps it fed. The authors call this criticism a textual gradient. Each variable is then rewritten by a language model asked to improve it in the light of the criticism. The interface deliberately copies PyTorch, the standard software for backpropagation.

The results are real. In the preprint, TextGrad raised the zero-shot accuracy of GPT-4o on a hard question-answering benchmark from 51 to 55 per cent, and gave a 20 per cent relative gain on hard coding problems (Yuksekgonul et al. 2024). My question is narrower. Which of backpropagation's requirements does the method keep?

Checking the requirements#

Ordering (R5): kept. The framework builds the graph on the forward run and visits it in reverse.

Stored activity (R1): kept. Every intermediate text is stored, so each critique can refer to what the step actually produced.

Per-unit errors (R3): partly kept. Each variable receives its own critique. But a critique is not a signed number. It names problems and suggests changes, and it can point in several directions at once.

Local derivatives (R2): not kept. No step has a formula for how its output changes when its input changes. A language model guesses, from the text, what the upstream step should have done differently.

Weight transport (R4): not applicable. The backward critic need not resemble the forward step. In that respect the method is closer to feedback alignment than to backpropagation, with a critic in place of a fixed random matrix.

What follows from this list is the key point. Backpropagation's guarantee comes from R2. Because each node multiplies by its true local derivative, the adjoints compose exactly, and a small step against them is certain to reduce the loss. Without local derivatives, there is no reason for a chain of critiques to compose into a direction that lowers the loss. Each critique may be sensible. The chain of them has no such warranty.

A counterexample from the instrument#

The instrument contains a direct warning for agent pipelines. Two of the ablations kept a backward chain and broke its arithmetic. Scrambling the per-unit errors gave 0.153, no better than training the output layer alone. Removing the local derivatives gave 0.134. In both, every unit still received an error that came backwards through the graph. The errors simply did not mean what the unit needed them to mean.

So a backward chain alone does not guarantee useful credit. A chain of critiques could be like the scrambled run, or like the full method, and from the outside the two look alike. The test for an agent pipeline is a comparison with a baseline that skips the chain, sending the final critique straight to every step, as direct feedback alignment does for networks. If the chain adds nothing over that baseline, the word gradient is decoration.

What Vikram should measure#

The analysis gives Vikram a short list of checks. First, run the baseline that sends the final critique straight to each step, without the backward chain. Second, measure whether the improvement grows or shrinks as the pipeline gets longer; exact backpropagation does not degrade with depth in this way, while chains of interpretation might. Third, check whether repeated rounds keep lowering the loss or start to oscillate, which would show that the critiques do not compose into a consistent direction.

These checks are not a verdict on the method. Language models are trained on vast amounts of human criticism, and it would be no surprise if their critiques often compose well. The point is that this would be an empirical fact about the critics, not a mathematical fact about the method. Backpropagation's guarantee holds for any differentiable graph, however strange. A chain of critiques works only as well as the critics understand the steps they criticise.

There is a further difference that matters for Vikram. In backpropagation, the adjoint at a node does not depend on who wrote the node. In a chain of critiques, each critique depends on the critic's reading of the step, which depends on how the step was described. Rename a prompt, and the backward messages may change. A credit signal that depends on description in this way is closer to the dance teacher's calls than to a derivative.

None of this says the method is bad. The checks say what the analogy promises and how to find out whether it keeps the promise.

Shankara's remark at lunch points to one of the most careful treatments of delayed credit in any tradition. Pūrva Mīmāṃsā is the school of Indian thought devoted to interpreting the Vedic injunctions to sacrifice. Its founding text, the Mīmāṃsāsūtra attributed to Jaimini, and the commentary of Śabara, set out rules for deciding which part of a ritual serves which other part. Kumārila, in the seventh century, developed the theory of the unseen result.

The problem the tradition faced#

A great Vedic sacrifice is made of many acts: kindling, pouring, reciting, offering. Each act is over in moments. The promised result, heaven for instance, comes much later. So how can an act that has ended cause a result that has not yet begun? Kumārila's answer, as the Bhāṭṭa school developed it, was to postulate an unseen potency, apūrva (अपूर्व), literally "the not-before", that arises from the sacrifice and lasts until the result appears (Freschi 2013).

The postulate was reached by a recognised form of reasoning, arthāpatti or presumption: if the scripture says the act yields the result, and the act has ended, something must persist to carry it (Freschi 2013).

The hierarchy of traces#

What makes the doctrine relevant here is its structure. A sacrifice is not one act but a graph of acts, ordered by subordination. The Mīmāṃsāsūtra states the principle in two words, śeṣaḥ parārthatvāt (3.1.2). A thing is subsidiary because it is for another. Śabara glosses it: that which works for the help of another is called the subsidiary, śeṣa (शेष) (Mīmāṃsāsūtra with Śabara, GRETIL). Kumārila puts the other end in a line that Uskokov translates: "That which is connected with the result is the principal, while that which is related to the principal is the subsidiary" (Uskokov 2026).

Later Mīmāṃsā authors then describe a hierarchy of apūrvas following that graph. In Ujjwala Jha's summary, using the new-moon and full-moon sacrifices as the example, each subsidiary rite generates its own apūrva (Jha, Mīmāṁsā Theory of Apūrva). The apūrvas of the subsidiaries together produce an utpattyapūrva for each main offering. These combine into two samudāyāpūrvas, one for each group of offerings. The two together produce the principal apūrva, pradhānāpūrva, also called paramāpūrva or phalāpūrva. That final potency, Jha writes, "would reside in the performer until the result is produced".

What the two schools add#

The two main schools of Mīmāṃsā read apūrva differently, and the difference is instructive. For the Bhāṭṭa school, following Kumārila, apūrva is a potency, perhaps a latent impression, that arises from the sacrifice and inheres in the sacrificer until the result comes (Freschi 2013). That is the reading in which the comparison with a stored trace makes sense.

For the Prābhākara school, apūrva is something else. It is the sacrifice's being "to be done", the duty expressed by the injunction itself (Freschi 2013). Cummins argues that Śālikanātha placed apūrva at the top of a hierarchy of meaning within the Vedic command, rather than treating it as a postulate outside language (Cummins 2021). On that reading, apūrva is closer to the loss function than to any trace: it defines what the whole graph of acts is for.

Yoshimizu, as Freschi reports, argues that even Śabara's early use of the word may not mean a potency left by the sacrifice (Freschi 2013). So the trace reading is one strand of the tradition, developed by one school. The comparison in this part is with that strand.

Where the doctrine and the mathematics agree#

Three features correspond closely. First, both treat a complex act as a graph of subordinate parts, with a principal connected to the result and subsidiaries connected to the principal. Second, both need something to persist across a delay. The apūrva lasts from the end of the rite until the result, much as an eligibility trace in e-prop lasts from a synapse's activity until the learning signal arrives (Bellec et al. 2020). Third, both combine traces from many parts into a few, in an order set by the graph.

What this means for RTM#

The Recognition Theory of Mind is a hypothesis under test, and it has five layers. They are spanda (L1), the pulse of activity; prakāśa (L2), something showing at all; and vimarśa (L3), the reflexive grasp in which a system takes its own activity as an object. Above them sit pratyabhijñā (L4), recognition, and cit (L5), consciousness as such.

Credit assignment, on the account in this paper, belongs to L3. To assign credit, a system must represent its own internal steps as well as the world, and how each step contributed to an outcome. Backpropagation does this mechanically and without any awareness. That makes it a useful lower bound. It shows that a reflexive operation over one's own activity can be fully mechanical and still powerful.

The comparison with apūrva sharpens the hypothesis. A system with traces but no corrective signal can carry the effects of its acts forward, but it cannot learn which act to change. If L3 is meant to include learning from one's own outcomes, it needs the backward half. RTM predicts that systems with forward traces but no signed, per-unit correction will hold habits but fail to form new internal representations. The instrument's readout-only and shared-score runs are a small, mechanical case of that prediction. They learned at the output and gained little inside. A test in animals would need the signed error to be blocked while traces remain, which the Part 4 proposals suggest may be possible.

[AUTHOR NOTE: if you have studied Mīmāṃsā or watched a long śrauta or gṛhya ritual with its subsidiary acts, one or two sentences on how the sequence felt from inside, and how mistakes were handled, would ground this part.]

The strongest objection to this paper is not that the brain obviously cannot do backpropagation. It is that the question is badly posed. Any system that improves by small steps in a direction that lowers its loss is following the gradient, on average. Weight perturbation does that. So does evolution, over generations. If "doing backpropagation" just means "following the gradient", everything that learns does it, and the requirements analysis is a matter of definition.

A second form of the objection is empirical. Brains learn from few examples, use much prior structure from development, and change their synapses by rules that are mostly local and modulated by broadcast signals. Perhaps the brain never needs per-unit signed errors in deep hierarchies, because it does not learn deep hierarchies from scratch. On this view the instrument tests a problem the brain does not have.

Both objections have force. My reply is that the five requirements are not definitions; they are costs. The instrument measured them. Following the gradient with one shared score was nine to thirty times worse than delivering a signed error to each unit, in a network of only 5,696 weights. That difference is not a matter of words. It is a measurable difference in how much information reaches each unit per trial.

The second objection deserves a better answer than I can give. It may be that development and evolution do most of the work, and that learning in adult cortex needs only a broadcast score acting on a well-prepared network. If so, the question of how the brain approximates backpropagation would shrink to a question about specific circuits. That would still leave the requirements as the right way to describe what each circuit can learn.

A third objection comes from inside machine learning. Hinton's forward-forward algorithm and related methods give each layer its own local goal and drop the backward sweep altogether (Hinton 2022). If learning without any backward signal works well enough, the five requirements describe one method among many and say little about learning in general.

My reply is that this is a change of objective, not a removal of the requirements. A layer with its own goal still needs a signed, per-unit signal about that goal. It simply computes the signal locally instead of receiving it from above. The cost moves from the backward channel to the design of the local goals. Whether good local goals can be found for hard tasks without anything like a backward signal is open, and so far they fall short.

I would give up the central claim, that the per-unit signed error is the requirement that matters most, if any of the following were shown.

A shared score that scales. A learning rule using one broadcast score per trial that trains networks of tens of thousands of units as fast as backpropagation, with no hidden per-unit signal.

Weight transport that matters most. Experiments showing that, across depths and tasks, removing weight transport costs more than removing the per-unit sign. Bartunov's results point partly this way for large image tasks, so this is a live possibility (Bartunov et al. 2018).

Composition without derivatives. Agent pipelines whose backward chains of critique consistently beat a baseline that sends the final critique to every step, by a margin that grows with depth. That would show that interpretation can compose as reliably as derivatives.

A mismatch in RTM. Animals in which signed teaching signals are blocked, with eligibility traces intact, that still form new internal representations at normal rates. That would count against the RTM prediction above.

What I still don't know#

I do not know whether my ordering of the requirements survives in deep networks. The instrument used two hidden layers. Feedback alignment is known to degrade with depth, so the cost of removing weight transport probably grows; I have not measured how fast.

I do not know whether cortical bursts or apical dendrites actually carry signed, neuron-specific teaching signals in a behaving animal. The models are detailed; the decisive recordings are not yet in.

I do not know how much textual-gradient methods gain from the backward chain itself, as opposed to the final critique alone. I have not found a published comparison that isolates it.

I do not know how the Mīmāṃsā authors would have treated a case where the result failed to appear. Whether the tradition has resources for something like a corrective signal, perhaps in its rules for expiation, is a textual question I cannot yet answer.

Invented scenario The scene below continues the invented story.

A month after Ugadi, Vikram sends his sister a chart. He has run his agent pipeline two ways on the same 200 customer complaints. In one, the critique passes backwards through every step. In the other, the final critique goes straight to all four steps at once. The difference is small. The backward version is a little better on the longest replies and a little worse on short ones.

"So it is not backprop," he writes.

"It is credit assignment," Priya replies. "Backprop is one way of doing it, the way with a guarantee. Yours is another, with a critic instead of a derivative. Now you know which of the requirements you kept."

Priya has her own version of the lesson. Her laboratory had been asking whether cortex does backpropagation, a question with no clean answer. She now asks a narrower one: whether a signed signal specific to each neuron reaches the apical dendrites of her recorded cells during learning, and whether its sign predicts the change that follows. That question has an answer, and her recordings can give it. Shankara, told about both charts, says only that the old authors also cared most about which act served which.

The answer to the paper's question can now be given in full. Backpropagation, derived from the chain rule, needs stored activity, local derivatives, signed per-unit errors, weight transport and an ordering of the two sweeps. Each node uses only local information, so the method is local; the backward channel is what makes it hard. Removing the requirements one at a time showed that they are not equal. Weight transport turned out cheap, the signed per-unit error expensive, and stored activity indispensable.

Biological proposals should therefore be judged by whether they deliver a signed, per-unit error and keep the record it refers to. Several do, by different routes: error units, apical dendrites, bursts and eligibility traces. Agent-level analogies should be judged by whether their backward chain does better than a broadcast critique. The Mīmāṃsā doctrine of apūrva shows that a tradition can model the forward half of credit, traces combined up a graph across a delay, with great precision and no backward half at all.

Start with Griewank's short history, which shows that reverse-mode differentiation began as a way of tracking rounding errors (Griewank 2012). Baydin and colleagues then give a clear modern survey of automatic differentiation (Baydin et al. 2018). For the method as a learning rule, read Rumelhart, Hinton and Williams; this site's reading of their 1986 paper gives the context (Rumelhart, Hinton and Williams 1986).

For the biological question, read Crick's commentary first, for the objection in its original form (Crick 1989). Then read Lillicrap and colleagues on random feedback, which changed the terms of the debate (Lillicrap et al. 2016), and their 2020 review, which sorts the proposals (Lillicrap et al. 2020). Werfel, Xie and Seung explain why one shared score scales badly (Werfel, Xie and Seung 2005).

For the agent-level analogy, the TextGrad paper is short and clear about its inspiration (Yuksekgonul et al. 2025). For the Mīmāṃsā material, start with Uskokov's chapter on the model of principal and subsidiary (Uskokov 2026). Jha's article describes the hierarchy of apūrvas (Jha, Mīmāṁsā Theory of Apūrva). Freschi's note on Yoshimizu explains how the schools disagree about what apūrva is (Freschi 2013), and Cummins traces the Prābhākara doctrine in detail (Cummins 2021).

Each source was opened and checked against its publisher page, DOI record, arXiv record or a primary-text edition before it was cited. Anything I could not confirm is marked “to verify”.

Primary research

1. Linnainmaa, S. (1976). Taylor expansion of the accumulated rounding error. BIT 16, 146–160. https://doi.org/10.1007/BF01931367
2. Griewank, A. (2012). Who Invented the Reverse Mode of Differentiation? Documenta Mathematica, Extra Volume ISMP, 389–400. https://doi.org/10.4171/DMS/6/38
3. Baydin, A. G., Pearlmutter, B. A., Radul, A. A., and Siskind, J. M. (2018). Automatic differentiation in machine learning: a survey. Journal of Machine Learning Research 18(153), 1–43. arXiv:1502.05767. https://arxiv.org/abs/1502.05767
4. Rumelhart, D. E., Hinton, G. E., and Williams, R. J. (1986). Learning representations by back-propagating errors. Nature 323, 533–536. https://doi.org/10.1038/323533a0
5. Werbos, P. J. (1990). Backpropagation through time: what it does and how to do it. Proceedings of the IEEE 78(10), 1550–1560. https://doi.org/10.1109/5.58337
6. Grossberg, S. (1987). Competitive learning: From interactive activation to adaptive resonance. Cognitive Science 11(1), 23–63. https://doi.org/10.1111/j.1551-6708.1987.tb00862.x
7. Crick, F. (1989). The recent excitement about neural networks. Nature 337, 129–132. https://doi.org/10.1038/337129a0
8. Lillicrap, T. P., Cownden, D., Tweed, D. B., and Akerman, C. J. (2016). Random synaptic feedback weights support error backpropagation for deep learning. Nature Communications 7, 13276. https://doi.org/10.1038/ncomms13276
9. Nøkland, A. (2016). Direct Feedback Alignment Provides Learning in Deep Neural Networks. Advances in Neural Information Processing Systems 29. arXiv:1609.01596. https://arxiv.org/abs/1609.01596
10. Bartunov, S., Santoro, A., Richards, B. A., Marris, L., Hinton, G. E., and Lillicrap, T. (2018). Assessing the Scalability of Biologically-Motivated Deep Learning Algorithms and Architectures. Advances in Neural Information Processing Systems 31. arXiv:1807.04587. https://arxiv.org/abs/1807.04587
11. Lillicrap, T. P., Santoro, A., Marris, L., Akerman, C. J., and Hinton, G. (2020). Backpropagation and the brain. Nature Reviews Neuroscience 21, 335–346. https://doi.org/10.1038/s41583-020-0277-3
12. Williams, R. J. (1992). Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning 8, 229–256. https://doi.org/10.1007/BF00992696
13. Werfel, J., Xie, X., and Seung, H. S. (2005). Learning curves for stochastic gradient descent in linear feedforward networks. Neural Computation 17(12), 2699–2718. https://doi.org/10.1162/089976605774320539
14. Fiete, I. R., and Seung, H. S. (2006). Gradient learning in spiking neural networks by dynamic perturbation of conductances. Physical Review Letters 97, 048104. https://doi.org/10.1103/PhysRevLett.97.048104
15. Whittington, J. C. R., and Bogacz, R. (2017). An Approximation of the Error Backpropagation Algorithm in a Predictive Coding Network with Local Hebbian Synaptic Plasticity. Neural Computation 29(5), 1229–1262. https://doi.org/10.1162/NECO_a_00949
16. Millidge, B., Tschantz, A., and Buckley, C. L. (2020). Predictive Coding Approximates Backprop along Arbitrary Computation Graphs. arXiv:2006.04182. https://arxiv.org/abs/2006.04182
17. Scellier, B., and Bengio, Y. (2017). Equilibrium Propagation: Bridging the Gap between Energy-Based Models and Backpropagation. Frontiers in Computational Neuroscience 11, 24. https://doi.org/10.3389/fncom.2017.00024
18. Sacramento, J., Costa, R. P., Bengio, Y., and Senn, W. (2018). Dendritic cortical microcircuits approximate the backpropagation algorithm. Advances in Neural Information Processing Systems 31. arXiv:1810.11393. https://arxiv.org/abs/1810.11393
19. Payeur, A., Guerguiev, J., Zenke, F., Richards, B. A., and Naud, R. (2021). Burst-dependent synaptic plasticity can coordinate learning in hierarchical circuits. Nature Neuroscience 24, 1010–1019. https://doi.org/10.1038/s41593-021-00857-x
20. Bellec, G., Scherr, F., Subramoney, A., et al. (2020). A solution to the learning dilemma for recurrent networks of spiking neurons. Nature Communications 11, 3625. https://doi.org/10.1038/s41467-020-17236-y
21. Jaderberg, M., Czarnecki, W. M., Osindero, S., et al. (2016). Decoupled Neural Interfaces using Synthetic Gradients. arXiv:1608.05343. https://arxiv.org/abs/1608.05343
22. Hinton, G. (2022). The Forward-Forward Algorithm: Some Preliminary Investigations. arXiv:2212.13345. https://arxiv.org/abs/2212.13345
23. Yuksekgonul, M., Bianchi, F., Boen, J., Liu, S., Huang, Z., Guestrin, C., and Zou, J. (2024). TextGrad: Automatic "Differentiation" via Text. arXiv:2406.07496. https://arxiv.org/abs/2406.07496
24. Yuksekgonul, M., Bianchi, F., Boen, J., et al. (2025). Optimizing generative AI by backpropagating language model feedback. Nature 639, 609–616. https://doi.org/10.1038/s41586-025-08661-4

Primary texts and translations

1. Jaimini. Mīmāṃsāsūtra 1–7 with Śabara's Bhāṣya. Sanskrit text on GRETIL; sūtra 3.1.2 (śeṣaḥ parārthatvāt) and Śabara's gloss. https://gretil.sub.uni-goettingen.de/gretil/corpustei/transformations/html/sa_jaimini-mImAMsAsUtra-1-7-comm.htm

Secondary sources and leads

1. Uskokov, A. The Mīmāṁsā Model of Puruṣārtha and the Role of Scripture. In Deciphering the Hidden Meaning: Language and the Highest Good in Early Advaita Vedānta. Oxford University Press (published online 2026). Quotes Kumārila, Tantravārttika 2.1.1. https://academic.oup.com/book/63341/chapter/573343888
2. Jha, U. Mīmāṁsā Theory of Apūrva. Journal of East-West Thought. https://journals.calstate.edu/jet/article/download/2318/2092
3. Cummins, P. T. (2021). Commands and the Doctrine of the Apūrva in Prābhākara Mīmāṃsā. Journal of Hindu Studies 13(3), 203–. https://academic.oup.com/jhs/article-abstract/13/3/203/6055885
4. Freschi, E. (2013). Yoshimizu, apūrva and a new reading of the Mīmāṃsā schools. Blog review of Yoshimizu, K. (2000), Change of View on Apūrva from Śabarasvāmin to Kumārila, in S. Mayeda (ed.), The Way to Liberation, Manohar, 149–165. https://elisafreschi.com/2013/11/15/yoshimizu-apurva-and-a-new-reading-of-the-mima%E1%B9%83sa-schools/

Mahapatra, R. R. (2026). Backpropagation derived as local credit assignment through computation graphs. Mind Frontier, paper 14, version 1.0. Rajesh Ranjan Mahapatra. https://rajeshrmahapatra.com/papers/mind-frontier/U0379-backpropagation-as-local-credit-assignment.html (DOI to be assigned.)

@misc{mahapatra2026u0379,
  author       = {Mahapatra, Rajesh Ranjan},
  title        = {Backpropagation derived as local credit assignment through computation graphs},
  year         = {2026},
  howpublished = {Mind Frontier, paper 14},
  note         = {Version 1.0},
  doi          = {10.XXXX/placeholder},
  url          = {https://rajeshrmahapatra.com/papers/mind-frontier/U0379-backpropagation-as-local-credit-assignment.html}
}