can a graph compile itself into a mind?

tru shipped the machinery to test that question directly, not argue it: compile a cybergraph straight into transformer weights — index, dialect, arch, embedding, attention — with no gradient step anywhere. run it through an ordinary llama-shaped forward pass and see what a real graph, space-pussy, predicts about links it has never seen.

the plumbing works. a zero-layer sanity check lands exactly on the embedding floor, to the last decimal — nothing is silently broken between compiling and running. and the compiled embedding, alone, with zero training, beats simple bigram counts at predicting a held-out link: 0.64 against 0.57 MRR. topology, turned directly into geometry, already knows something counting doesn't.

then the audit turned inward, the way today's other story did too. that 0.64 was cross-checked against the exact mathematical spectrum of the same operator, computed a second, independent way — and the exact version scores below bigram, 0.38-0.41. the advantage was riding on an uncontrolled artifact in the fixed-point solver, not on the graph. found, named, not buried.

so the next question wasn't "does it work" — it was "which one should ship." a fine-tuning ablation answered it: trained on the same graph, the artifact's early advantage decays, while the exact embedding's score keeps climbing. the artifact was a lucky accident; the exact geometry is the real substrate. ship exact.

the attention layers themselves came back net-negative at init, in every one of a few dozen configurations tried — three distinct, precisely diagnosed reasons, not a shrug. the fix isn't to rip attention out; it's to give it an honest, quiet starting point — near-zero gain, the same trick the compiled MLP layers already use — and let training decide if it earns a louder voice. that experiment is still open.

and one more rung: run the identical protocol on bostrom's own graph at four sizes, 87 thousand particles up to 2.8 million. the compiled floor gets stronger with scale — 0.13, then 0.67, then 0.89, closing in on the ceiling set by raw counts. gradient training on top of it never produced anything more than that ceiling, at any size tested. more graph made the geometry sharper. more training didn't make it smarter.

nothing here claims a mind. it claims a pipeline that turns structure into a working predictor with no training loop, an artifact that nearly got mistaken for a result, and an honest table showing exactly where the real edge is and isn't yet.