Instead of judging an AI by how smart it looks today, what if you scored it by how well its future upgrades actually turn out?

This explores whether you can score a self-modifying agent by how well its descendants perform, rather than by how good it looks right now, and how close that comes to the theoretically ideal choice about which self-changes to keep. One caveat up front: the collection doesn't hold the work that introduced 'clade-level metaproductivity' (the Huxley-Gödel Machine line of research), so it can't settle the formal comparison. That research argues that if you knew a modification's true lineage payoff, you could make the same accept-or-reject choices as a Gödel Machine, the idealized agent that only rewrites itself when it can prove the rewrite helps. In practice the lineage payoff has to be estimated from a limited number of descendants that were actually tried. What the collection does offer is several angles on the main problem underneath: a change's immediate score and its long-run value are often different things.

The closest mechanical parallel comes from tree search. Can tree structure alone convert outcome rewards into process supervision? shows that a branching structure can turn one final outcome into credit for each step, by comparing how sibling subtrees turn out. Scoring a clade works the same way: a node is judged by what grows beneath it. Can tree search replace human feedback in LLM training? makes the same move for training data, where the tree's results stand in for human labels. Both teach the same lesson. Subtree estimates are only as good as the branches you can afford to explore, and that cost is the gap between an estimated lineage score and the true optimum.

There is a direct example of why scoring by immediate performance misleads. Do stronger models always evolve harnesses better? finds that models of every strength write roughly equally useful edits to their own scaffolding, but how much they gain from those edits peaks at mid-tier models. So the quality of a self-edit and its actual payoff come apart, and a selector that only looks at the edit itself will pick wrong. Lineage scoring is one attempt to measure the payoff instead.

The bigger caution is that any score of this kind is still an external measuring stick. Can models reliably improve themselves without external feedback? argues that self-improvement that works always brings in an outside anchor, and a clade's score is anchored to whatever benchmark the descendants are tested on. That fits Are self-refinement and recursive self-improvement actually the same thing?: what works today is bounded, checkable refinement, not open-ended self-rewriting. A practical detail from Do self-improving agents really split into two distinct loops? explains why lineage search is workable at all: most self-modification now happens in prompts, memory and tools rather than in model weights, so many branches can be tried cheaply and abandoned.

The takeaway you might not have expected: the hard part of self-improvement may be less about making good changes and more about knowing which changes will pay off several generations later. That makes it a credit-assignment problem, the same one that runs through tree search and reinforcement learning.