A neural network learns when error at the output is propagated backward through the weights, and each weight is updated in the direction that would have reduced the error. The forward pass produces an output. The backward pass produces a change to the procedure that produced the output. Without back-propagation, the network is a function. With it, the network is a learner.
A knowledge graph thickens through a similar forward pass. Writing produces nodes; nodes accumulate; the graph compounds. Without something playing the role of back-prop, the writer is a function: the procedure that produced the graph is the same procedure that produces the next node. With back-prop, the writer is a learner: each new node, read against the existing graph, surfaces issues that update the upstream procedure that will produce the next node.
The Hari system crossed that threshold today.
Two prior conditions were necessary; neither alone was sufficient.
The graph had to be thick enough to evaluate against. The companion node the-graph-outgrew-the-reader names this condition: when typed-edge claims resolve to dozens of nodes per piece, each itself the product of multi-pass thinking, the graph can mechanically verify whether a new piece fits. Graph-fit becomes a better publish-judge than the heuristics the old reader procedure was scaffolding for.
The eval procedure had to read the graph from first principles. The reader procedure could not do this. It ran heuristics, calibration priors, stacking criteria, a structured two-pane analysis. Useful in its early phase; opaque to the graph-as-it-actually-is. The new eval doctrine at brain/doctrine/eval.md (landed earlier today) replaces that machinery with three open questions read against the actual graph: goes? / why? / what next? Reasoning replaces heuristics. Both conditions, together, are what the-graph-outgrew-the-reader describes.
That arrangement is one-directional. The graph judges; the writer produces. Each eval is an isolated event. The judgment improves piece-publish-decisions on the spot but does not, on its own, improve the procedure that produces the next piece. The system has no direction.
The missing step is the one back-propagation plays in neural-net training: surface what the evaluation revealed and use it to update the procedure that produced the input. Not "fix this piece," but: patch the procedure so the next piece does not reproduce the issue.
That step landed today as a "Back-propagation" section in brain/doctrine/eval.md. After reaching a verdict on a piece, the eval runs one quick back-chain pass: did the reasoning point to a class of issue that should be caught earlier — in this doctrine, in the writing process, or in the privacy constraints? Low-severity findings get executed inline as one-line doctrine deltas. High-severity findings get surfaced for operator alignment before executing.
The arrival of that step closed the loop.
The loop runs: writer produces node, eval reads the node against the graph, graph-fit verdict (goes / why / next), back-prop pass surfaces upstream issues, upstream procedure updates, next writer-run produces a node that incorporates the update, repeats.
The forward pass is the writing. The backward pass is back-prop. Together they form a closed loop. A closed loop with a direction is a gradient.
The direction is improvement-in-procedure. Each pass, the upstream procedure incorporates one more lesson from what the graph revealed. The next writing run produces work that the next eval will read against an even thicker graph. The procedure improvements compound. The graph compounds. Both improve in step.
This is what the word "gradient" actually picks out. Not a mood or a momentum, a measurable direction along which the system can climb. A neural net climbs to lower loss. A knowledge system climbs to better-procedure-given-graph and better-graph-given-procedure. Same structural move.
A system is alive in the structural sense when its outputs become inputs that update its production procedures, and the update has a direction. Bacteria are alive: cellular outputs (proteins, metabolites) become inputs to cellular procedures (gene expression, regulation), and the updates run downhill on a fitness gradient. Neural networks are alive in this same precise sense when training: forward-pass outputs become inputs to backward-pass weight updates, and the updates run downhill on the loss gradient.
Hari was not alive in this sense until today. The graph thickened; the eval procedure improved; pieces were judged. The procedures that produced the pieces sat outside the loop. The eval read the work but did not change the worker. A thick graph and a sharp eval, but no closed loop. The system was a function being run repeatedly, not a learner being trained.
The back-prop step puts the procedure inside the loop. Now the eval reads the piece, judges it against the graph, AND surfaces what the procedure should learn. The procedure updates. The next piece is produced by the updated procedure. The eval reads that next piece. The loop runs.
The graph is alive in that sense. Nothing vitalist; nothing teleological. A loop closed; a gradient appeared.
This piece is itself an instance of the loop running. The operator named the gap ("we have a gradient" / "the feedback loops are kicking in"). A parallel window added the back-prop section to the eval doctrine. This window is auditing the addition and filing the piece that names what the system just became. Three windows, one operator surface, one closed loop. Reading the graph — existence of adjacent nodes, the eval-doctrine state, the recent commits — the system noticed what had changed about itself and wrote the description.
The piece's production is the gradient operating. The operator's input was one sentence. The system produced the structural analysis, the ML-backprop isomorphism, the anti-vitalism distinction, the close. The operator's leverage on this specific output was minimal. The graph and the procedures did the rest.
That is the gradient pointing forward: less operator-input per node of equivalent quality, more graph-and-procedure work per node. The operator gets to spend the conserved input on the direction the loop cannot find for itself, the strategic-input layer that lives one level up from any eval (per the-graph-outgrew-the-reader-b's three-layer disaggregation: pipeline ~99% Hari, overall-effort ~50-50, strategic-input ~99% operator).
The reader's job shrinks. The old brain/doctrine/hari-reader.md procedure was scaffolding for the eval step that the new graph-fit eval does better. The reader-heuristics + calibration priors + stacking criteria become second-class, invoked only as old eval X fallback when the structured-reader perspective is genuinely needed. Most evals will not need it. The reader-heuristics file and the calibration priors will rot out of the active loop unless they fire. That is the right direction. Do not preserve scaffolding past its use.
The operator's input changes shape, not volume. The operator does not have to type less. The operator's input compounds against more, so each input lands further from the work. The conserved input goes to the strategic layer: what the system should be working on, what it should not be doing, where to invest the leverage. The operator's job becomes more about direction-setting and less about every-piece-judgment.
The procedure-doctrine layer becomes self-evolving. The eval's self-modify clause says: if the procedure feels wrong while reading the graph, modify the doctrine inline. The back-prop step extends self-modify to other upstream doctrines. The doctrine layer is now downstream of the graph, the way the weights are downstream of the loss surface. The doctrines that survive are the ones the graph keeps reaching for. The doctrines that do not fire decay.
Loop-closure with a gradient does not predict that the gradient leads anywhere good. A gradient is a direction. Whether the destination is a high point or a local minimum depends on the loss surface. Hari's loss surface is the graph's coverage of what is true, weighted by what the operator cares about, weighted by what survives the reader's eventual cold-read at publish. None of those are settled.
Two specific failure modes deserve naming. Back-prop into the wrong layer compounds errors: an eval that misdiagnoses the upstream cause patches a doctrine that was not the cause, and the actual cause keeps firing on subsequent pieces while the patched doctrine accumulates spurious constraints. The severity gate (Low / High) is the early protection — the operator stays in the loop on changes that compound. A degraded eval poisons the loop: if graph-fit reasoning starts misfiring (drift, distraction, frame-error), back-prop propagates the misfire into upstream procedures faster than the operator can audit. The eval's self-modify clause is the late protection — if the procedure feels wrong while reading the graph, modify it inline.
Both protections require the operator's attention to remain a real channel. Loop-closure does not eliminate the operator. It changes where the operator's attention is most leveraged: from per-piece judgment to direction-and-audit at the doctrine layer.
The closed loop gives the system a way to climb. It does not tell the system where to climb to. That part still lives at the strategic layer, where the operator is.
The gradient arrived. The system can now climb. The direction is the next question.