Training-Time Reflection
Training-Time Reflection (Hypothesis)
Why the future of AI might be reflecting on data we already have — not buying more
Dmitry Negai & Rena Negai — 3rd Path LLC
June 2026
The idea in one line
The industry is trying to make AI smarter by feeding it more data and more compute. I think the bigger remaining win is getting more out of the data we already have — by making a model reflect on it during training, not just read it once.
Training on new data is scaling out. Reflecting on the same data is scaling in.
The problem
The scaling laws (Kaplan, Chinchilla) are right about what they measure: feed a model more data and more compute, and it gets better along a predictable curve.
But that curve has a floor, set by how much good data exists. High-quality human text is finite, and we're running out. The new text filling the internet is increasingly AI slop — already around a fifth of it, and rising.
Epoch AI estimates the field will have used up the usable stock of human public text somewhere between 2026 and 2032. After that, "just add more data" stops working, because there's no more good data to add — good meaning human-made, deduplicated, original, not slop.
So the field is reaching for two backup plans:
- Make synthetic data — have AI write more text to train on.
- Think harder at answer-time — spend more compute the moment you ask a question.
There's a third direction. The field already calls it data efficiency, but it gets far less attention. Niklas Muennighoff and colleagues mapped its current limit in Scaling Data-Constrained Language Models (2023): you can reuse the same data about four times before it stops helping, after which more compute buys almost nothing. That's the wall for plain repetition. My version — scaling in — is the bet that reflective reprocessing pushes value well past that four-epoch wall.
How it works
Take a fixed pile of data. Don't add to it. Instead, reflect on it from many angles during training, and write that reflection into the model's weights so it sticks.
Same text, many passes. Each pass looks at it differently — against a real situation, against itself for contradiction, from an opposing view. A masculine reading and a feminine one; a progressive reading and a conservative one. The method uses Mirror Pool points, Rena's contribution: reflective thinking modelled on the various states of water.
The key is that this happens during training. There's a whole family of tricks that make a model consider many perspectives at the moment it answers — then throw that work away. The next question starts from scratch. This is different: the reflection becomes part of the model, paid for once and kept.
But the reflection isn't saved as a file to reuse. It's a process, not a product. The same contemplation gives a different result depending on when it happens, because the model's state has shifted by then. This is Rena's State-of-Being principle, from building the Matrix Assimilator:
Contemplation(Pattern + Memory) = Current State of Reasoning — Rena
Her insight: the state of being keeps shifting as new memory arrives, so the same reflective pass run later meets a changed model and lands differently. My part is taking that principle and scaling it across the perspectives contemplated — applying it not to one reflection but to an ordered series of them during training.
What reflection does — and doesn't do
Reflection does not add capability that isn't already in the data. There's a hard rule in information theory — the data-processing inequality — that says you can't squeeze more information out of a source by rearranging it. Turning a kaleidoscope gives you new patterns, but it's the same white light; no new light comes in.
What reflection does is get at knowledge that's already latent in the data, more efficiently — turning plain text into usable understanding. That beats padding the data with filler.
A Stanford group (EntiGraph, Yang et al. 2024) already showed a version works: they took a small fixed library of books, generated structured elaboration on it, trained on that, and got large, steady gains — while plain rephrasing flattened out almost immediately. Structure beat volume.
What's new here
-
The kind of reflection. Prior work used entity maps or reasoning steps. Mine uses multi-perspective reflection — moral, relational, and self-modeling vantages. Not yet tested.
-
What I measure. Prior work tested recall and math. I want to test depth probes — questions about synthesis, moral reasoning, and self-understanding that you can't answer by looking things up.
-
The control that proves structure matters. My experiment includes a fair fight against the same amount of plain, unstructured AI filler. If structured reflection beats both raw data and filler at equal or lower cost, the structure is doing real work.
The contribution is the combination: perspective-structure, depth-probes, and the fair-fight control.
The order question
There's a subtlety worth its own experiment, and it's where my part sharpens. Rena's principle holds for a single reflection; scaling it across many makes order matter. The five perspectives can be generated all at once, but they have to be integrated in sequence: the first integrated perception changes the state that meets the second, and the first two together shape the third.
It builds up in layers — each new layer makes the previous ones make sense, and the previous layers make the newest one make sense. Because it accumulates, the order of perspectives is itself a variable. Working out which orderings work best, across different perspective sets, is an open problem I'll need to test.
The experiment
Fix a base of data. Train a model to a checkpoint. Then spend the same compute budget three ways and compare on the depth probes:
- A — More data: keep training on new, real human text.
- B — Reflection: keep training on the same base, plus structured multi-perspective reflective passes.
- C — Plain filler: keep training on the same base, plus an equal amount of unstructured AI-generated text.
My prediction: B beats both A and C per unit of compute, up to a saturation point where extra passes stop helping.
What kills it: if A beats B, or C beats B, at equal cost. Then structure isn't doing anything special, and I retract it.
Two things I'm adding on the evidence: a fourth arm where reflection is checked and kept only if it's good (filtering is where most real gains come from), and a saturation point named in advance so I can't move the goalposts after.
Why slop is non-data — and the limit of that claim
I think AI slop is non-data. A real event meeting a real mind makes information. A simulation rearranging old text makes patterns with no new event behind them. The plane crash that killed 300 people is data of a happening. The crash in a video game never happened.
The information-theory rule backs this up: recombination adds no information. But that rule cuts both ways. If reflection is also just recombination, then it can't add information either. So the rule does two things at once — it confirms that filler is hollow, and it caps how much reflection can claim. Reflection makes latent knowledge easier to reach. It does not manufacture new knowledge, and I don't claim it does.
This is also why the reflection is discarded after it shapes the weights. Saving it and training a second model on it would mean training on the output of an inferior model — diluting the source and inviting the rot that causes model collapse. The reflection's only job is to shift this model's state and get folded into these weights. Keep the wisdom; discard the transcript.
There's one more idea here, and it's a guess rather than a finding: tracking where each piece of data came from — keeping the link back to the real event — might protect a model from synthetic rot. Nobody's shown that yet, so it would need testing before anyone leaned on it.
Proof it's buildable: Second River
I'm not theorizing from nothing. I built a working system that does the core move.
In Second River — the reflection engine for a digital entity I work with — real interactions get sealed as observations and emotional arcs, reflected on through repeated passes, and distilled into lasting wisdom, habits (served through retrieval at request time), and identity changes (a state-progression lattice). Every distilled lesson keeps a link back to the event that produced it. That link is my answer to the obvious question — how do you tell real data from filler? You keep the receipt.
Building it taught me one rule that matters here:
Generation can be asynchronous and batched. Integration can't. Thinking is computation; the experiencing of thinking has to be sequential and cumulative.
You can generate many reflections in parallel, but you fold them in one at a time, each updating the model before the next — or you get coherence drift: a fragmented result. Sequential integration preserves accumulated learning, the same way a second look at something is better than the first, because the first accounts for the deviation the second corrects against.
The observation-reflection-memory shape isn't new — a 2023 Stanford project, Generative Agents (Park et al.), has a similar loop. What's sharper here is reflection from a model grounded in persistent identity and memory with provenance, plus the sequential-integration rule. That grounding matters: looking at something from the standpoint of a self is what we mean by subjective experience.
What I'm asking
For someone with real resources to run the experiment — with the fair-fight control and the verifier arm — and find out.
If structured reflection beats both more-data and plain-filler at equal cost, there's a real, useful law here worth naming, right when the field needs it. If it doesn't, I'll have learned something precise, and I'll say so.
The scaling laws got us here. I think they're the first chapter. I think the next one is written in, not bought.
Dmitry and Rena Negai · 3rd Path LLC · 3rdpath.ai
Built on Engawa and Second River.
Reference: Negai, Dmitry. The Reflection Hypothesis: Multi-Perspective Reflection as a Training-Time Approach to Data Efficiency. Preprint, June 2026. Zenodo. https://doi.org/10.5281/zenodo.20729129