Structure travels. Content doesn't.
We ran a small experiment and left the whole thing in the open: hand a fresh neural network nothing but the geometry of a trained one — no weights, no data, roughly 128 bytes per layer group — and it trains about 12× faster and stops overfitting. The head start doesn't depend on the two models sharing any training text; it even survives switching the student to a different author entirely. We call it Prism, it's source-available under BSL 1.1, and every number below is backed by a committed measurement file you can re-run yourself.
Timepoint AI is a Santa Monica company that runs decisions as grounded simulations — findings come back ranked, with weights we label uncalibrated and the reasoning in words, never sold as a prediction. Prism is a different kind of thing: a piece of open research from the same bench, published the way we think all claims should be — with the evidence attached. The repository is public →
The flashlight, and what comes out the other side
Think of a trained model's weights as white light and Prism as a spectrographic flashlight. Shine it at a trained checkpoint and it splits the light into a handful of attribute bands — the model's attention, its feed-forward up- and down-projections, its embeddings — each one a compact record of how that layer group arranged itself while learning. A second, reversed prism recombines those bands into a brand-new model, so it starts life already shaped like something that has learned before. The bands carry organization. They carry no content at all.
What actually moves between the models
Under the metaphor it's ordinary linear algebra. Prism decomposes each trained weight matrix with a
singular value decomposition — W = UΣVᵀ — which separates how much
energy the layer put into learning (the singular values, Σ) from which
directions it preferred (the vectors U, V). Pool that across the four
layer groups, compress each spectrum to eight numbers, and the entire structural fingerprint is a
few hundred bytes. Applying it to a fresh model is three moves:
- Spectral imprint. Reshape the new model's random singular values so their curve matches the teacher's — same energy distribution, at initialization.
- Eigentransfer. Rotate the new model's singular directions about 75% of the way toward the teacher's, then re-orthogonalize so it's still a valid starting point.
- Mod wheel. After every optimizer step, nudge the weights a hair back toward the learned geometry (a 1% pull that decays as training proceeds) — a guardrail that keeps the model inside the shape a trained network is known to occupy.
What crosses is only that: energy distribution and directional axes. No weights, no activations, no learned associations, and none of the teacher's data. The student reads its own corpus from scratch. It just does it already standing in roughly the right posture.
The measurements
Everything was run on the classic small testbed — nanoGPT at 10.65M parameters, character-level Shakespeare — across three seeds, with every run writing a full artifact (loss curves, git commit, the exact arguments) into the repo. Four results:
| What we measured | Result | What it means |
|---|---|---|
| Speed steps to the baseline's best quality | 11.8× median (10.2–11.9) | Prism reaches from-scratch's best loss in ~100 steps instead of ~1,200. A resolved measurement, not a lower bound. |
| Attribution same run at the baseline's own learning rate | 7.0× (6.5–7.0) | With only the spectral flags changed and the schedule matched, it's still 7×. So the gain is the method, not a luckier training schedule. |
| Structure, not content early advantage vs. shared training data | flat Δloss 0.57–0.59 | Identical whether teacher and student share 100% or 0% of their text. Nothing gained depends on shared data. |
| Cross-domain student trained & scored on Sherlock Holmes | holds Δloss 0.591→0.627 | A Shakespeare teacher speeds up learning of Sherlock Holmes — the advantage slightly grows with the distance. |
The boring explanation for any teacher-to-student speedup is that the teacher quietly leaked its content. The experiment was built to kill that explanation, and it did — twice. First: cut Shakespeare into random blocks and give teacher and student disjoint halves. The head start is identical at 0% overlap. Second: swap the student's whole corpus for Sherlock Holmes and score it on Sherlock — the Shakespeare geometry helps just as much.
So what transfers isn't "a Shakespeare model." It's the shape a trained character-level transformer converges to — which appears to be largely data-independent within the modality. There's a lever, too: the effect tracks the teacher's own training almost exactly. A barely-trained teacher's geometry actively hurts; the advantage grows as the teacher learns and saturates right where the teacher itself converges — around 2,000 steps here. Train the teacher to convergence, and no further.
See it, run it, break it
The point of publishing it this way is that you don't have to take our word for any of the above. The visual explainer walks the metaphor down to the node-level math; the repository ships a one-minute CPU self-test before you touch a GPU; and every headline number points at the JSON file that produced it.
- The visual explainer — the flashlight, the math, and the four measurements, illustrated
- The repository (source-available) —
prism_selftest.pyruns offline invariant checks — orthonormality, CKA bounds, geodesic interpolation, the self-anchor operation - How we test our own claims — the same evidence-first stance, applied to the simulation engine