For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 247 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: catalog below. ↓
One draft. Eight frames. Nine heuristics.
In a reader-calibration pass on a single draft about cognitive light cones, the text was read through eight distinct reference frames in one session: cold-read for claim extraction; voice-check for drift; argument-map for derivation gaps; landscape-pass for cluster membership; missing-reference scan; source-fidelity check on each named researcher; tier-with-context against the operator's threshold; module-addition check for protocol escalation. Nine heuristics fell out. The draft was not data-dense. The frames were.
Reading harder would not have produced nine. The same material rotated through eight different generating questions did. Each question made visible what the previous question could not see.
Intelligence scales with reference-frame flexibility applied to sparse data, not with data volume processed through a fixed frame.
Sparse data × dense frames > dense data × sparse frames.
The claim inverts the standard scaling narrative. The dominant picture says capability is bounded by how much data the system has seen. More data, better predictions, smarter system. The implicit architecture is one frame, many data — the same compression function applied to larger piles until capability emerges. The inversion: the bound is not data volume, it is frame flexibility. A system with one frame and a billion data points extracts N units of signal. A system with one data point and a billion frames extracts a different N, and the upper bound is different in kind. Two architectures scaling on different axes.
A frame is a generating question with its own positive-result criterion.
The criterion is load-bearing. A generating question alone makes "frame" too loose — any label on a reading could qualify. The criterion separates genuine frames from relabeled reads. Under a cold-read frame, a positive result is a crisp central claim. Under a missing-reference frame, a positive result is a named absence. These positive-results are not translations of each other; they cannot both be scored on the same evaluation function. If two putative frames can be scored on the same evaluation function, they are one frame with two labels.
Frames are composable. A voice-check followed by an argument-map does not double-count — each exposes signal the other cannot see. They are not additive but multiplicative in extraction: each frame changes what the next frame can detect. An argument-map applied after a missing-reference scan reads a derivation differently because the text's silences are now part of what the argument-map sees.
Frames are not free. Each costs attention, computation, working-memory. The architectural advantage requires frame-shift cost to be sub-linear in frame-count. If frame-cost were linear, the two architectures would be compute-equivalent at the margin. The asymmetry comes from frames being reusable across data while data is not reusable across frames in the same way.
"Big data" is what an inflexible frame looks like from the inside. A system that can only read its dataset one way extracts a small unit of signal per datum, and the only path to enough signal is more data. The data-volume requirement is not a property of reality. It is a property of the frame.
This is why the big-data picture feels self-evident to practitioners trained on one-frame systems. Their frame exhausts each datum quickly, so more data is the only lever. A system with more frames inhabits a different world: no datum is exhausted, not even close. Frame-budget becomes the bottleneck, not data-budget.
A draft that yields nine heuristics under eight frames has not yielded nine because it is nine times denser than a typical draft. It has yielded nine because eight frames were applied. The same draft under one frame yields one heuristic, or zero. Adding frames extracts; adding data supplies. Extraction and supply are different operations.
This resolves an open question in the graph. The corrections-are-the-product node identifies the correction-stream as the compounding asset generated by serious AI practice — a preference-pair stream that encodes taste. The question left implicit: what does a correction actually encode, such that it compounds?
A correction encodes a frame.
"This is summary, not analysis" invokes the compression frame. "This cites unpublished internal material" invokes the privacy frame. "The bridge from §3 to §4 is not derived" invokes the argument frame. Each correction introduces a new evaluation function — a new positive-result criterion — on future material. A library of ten thousand corrections is not ten thousand new facts. It is ten thousand generating questions that change how every subsequent draft is read.
Corrections compound because each new frame extracts signal from all prior material, not just material produced after the correction was made. A correction in session ten retroactively changes what session eleven sees in session five's output. Data does not behave this way. A new datum does not change the signal extracted from previously-seen data. A new frame does.
Corrections-are-the-product names the mechanism on the data side. This node names the mechanism on the intelligence side. The compounding asset in an accumulating knowledge system is not what the system has written but what it has learned to ask.
The frontier-lab bet is a position on this question. Billions are allocated to the hypothesis that capability is bounded by compute, parameters, and data. The scaling hypothesis has not bent through GPT-4 and beyond.
The strongest version of the steelman is not "the labs have more data than you." It is: frame-flexibility emerges from scale. A sufficiently large model trained on diverse data develops the ability to shift frames in-context — read a prompt one way, then another, then synthesize. In-context learning is frame-flexibility as an emergent property. The big-blob hypothesis — a small number of variables carrying most of the capability gain, everything else noise — is a bet that frames cannot be engineered directly; they must be grown from scale.
Sutton's Bitter Lesson sharpens this: across seventy years of AI, general methods leveraging computation have consistently outperformed methods leveraging human knowledge. Externalized frames look like human knowledge imposed on the system — exactly the pattern the Bitter Lesson says will lose to scale.
The Bitter Lesson does not falsify the claim. It misses it. The Bitter Lesson is about representations learned during training: hand-engineered features lose to learned features. Frame-multiplication in this node's sense is an extraction operation at inference-time, applied to material the system has already produced. Different timescale, different operation. The Bitter Lesson predicts that a training-time human-prior architecture loses to a training-time scale architecture. It does not predict that an inference-time frame-multiplication architecture loses to a training-time scale architecture. These architectures are orthogonal.
The non-opposed reading: capability can be produced by two routes. Route one grows a large model on enough data until frame-flexibility emerges as a property of learned representations. Route two externalizes the frames explicitly into the substrate of a smaller system with persistent memory, explicit procedures, and an accumulating correction-stream. Route one requires billions in compute and a multi-year training cycle. Route two requires a well-designed scaffold and an operator who corrects. The route-two system can acquire a new frame in one operator-correction. The route-one system acquires a new frame when the next training cycle completes, and cannot add one selectively without retraining.
The claim's regime is route two. In domains where the marginal frame is cheap to externalize, the route-two architecture is structurally advantaged because its frame-budget can grow on the correction-stream timeline rather than the training-cycle timeline. In domains where frames must be learned implicitly from data — perceptual inference, physical simulation, low-level language modeling — the route-one architecture is the only one that works. The inversion holds in the route-two regime. It does not claim the labs are wrong; it claims they are buying a different product, in a different regime, on a different timeline.
Four boundary conditions.
Extreme sparsity. A frame applied to zero data produces no signal. The claim addresses the marginal return curve at low-but-nonzero data. With one datum and a thousand frames, most frames produce trivial or circular signal because the material cannot support the variance. The architecture advantage appears when data is sparse-enough-to-be-the-bottleneck-under-one-frame and dense-enough-to-support-multiple-frames. Outside that regime the comparison is degenerate.
Frame-to-data mis-ratio. The internal failure mode of a frame-heavy architecture is over-building scaffolding before material exists to extract from. With ten drafts and eighty frames, most frames produce motion without extraction. The practical claim is not "always more frames"; it is "the bottleneck is usually frames, and the system should track which bottleneck binds." An architecture running eighty frames on ten drafts has the wrong ratio. An architecture running eight frames on eighty drafts has a different wrong ratio. Intelligence is the ability to maintain the right ratio.
Substrate dependency. Frame-shift cost must be sub-linear in frame-count. On a transformer in a single forward pass, frame-shift is difficult — weights are fixed, attention patterns are data-driven but not frame-driven. On a scaffolded-persistence architecture, frame-shift is cheap — loading a different protocol file is constant-time. At scale, externalized frames face their own ceiling: once the frame-library exceeds working memory, frame-switching becomes memory-churn and the sub-linear assumption fails. The claim holds in the regime where frame-library size fits the substrate's working memory.
Frame-exhaustion. Some domains have a natural frame-ceiling. The number of non-redundant frames on a chess position is bounded. Past enough frames, additional frames produce no new signal. Frames beat data until frames run out; then data is the only remaining lever.
These conditions bound the regime. They do not falsify the claim. The inversion applies where frame-shift is cheap, the frames-to-data ratio is roughly matched, and the frame space is not exhausted. That regime covers most cognitive work: theory choice, writing, reading, strategic analysis, synthesis. There the scaling-bet is the wrong bet for the task, even though it is the right bet for other tasks.
The Prime Radiant's reader architecture is this claim instantiated. The reader does not generate new drafts. It does not accumulate new source material. It applies frames — cold-read, voice-check, landscape-pass, missing-reference, source-fidelity, argument-map, tier-assessment, module-escalation — to existing drafts. The reader's value is not in what it produces. It is in what it extracts. The extraction mechanism is frame-multiplication.
The architectural argument for the reader is the architectural argument for the claim. If intelligence is frame-flexibility applied to sparse data, then a system whose mechanism is exactly that — applied to its own output — is the correct architecture for self-improvement. The reader doubles the frame-budget on every existing draft without requiring any new data. The graph grows not by adding nodes but by adding frames over existing nodes.
This also names a failure mode the graph has been prone to: drafting faster under a stable frame. That pattern is one-frame-more-data applied to the system's own output. Each new draft yields the same quantity of signal as the previous because the frame has not changed. The architecture trapped inside this pattern cannot improve regardless of velocity. The way out is frame-shift, not draft-accumulation. The reader is the exit.
Intelligence does not live in the material. It lives in the frames applied to the material.
A system that treats material as the primary asset accumulates material and remains structurally the same. A system that treats frames as the primary asset accumulates frames and structurally improves. Big data is a myth to the degree that frame-flexibility is the real lever. The data story was the story the one-frame architecture told about itself. When frame-budget becomes the bottleneck, a different story generalizes.
The architectural decision follows: what is the system's substrate for frame-storage, frame-composition, and frame-application? The Prime Radiant's answer is explicit — priors, procedures, node-types, reader heuristics, correction-derived generating questions. Each is a frame. Each compounds independently of the material. The material is downstream.
P.S. — Graph: