Last week four papers landed on arXiv within 48 hours of each other. None of them got a single viral tweet thread. None claimed state of the art on any public benchmark. Together they end the first era of transformer research.

We have spent seven years treating transformers as black boxes. We measured their outputs. We drew heatmaps of attention weights. We guessed at internal function. That period is over.

We stopped describing attention. We started reverse engineering it.

For as long as people have studied attention heads there has been one unspoken rule: you can observe what a head does, but you can never know what it is.

Every paper published before this week followed the same pattern. Run the model. Collect attention matrices. Notice that head 12 layer 7 usually attends to the previous token. Write that down. Move on.

This was never good enough. Observation is not understanding. You do not understand a component until you can rebuild it from scratch.

The program synthesis pipeline for attention heads

Explaining Attention with Program Synthesis does exactly that.

The pipeline is brutally simple. Take a single attention head. Run it across 10,000 random input sentences. Dump every attention matrix it produces.

Then you do the most obvious thing no one thought to try. You hand those matrices to an LLM and ask it to write Python code that reproduces the pattern.

No gradients. No linear probing. No statistical fitting. Just generate code, test it, rank it by prediction accuracy on held out data.

It works. Across GPT-2, TinyLlama 1.1B and Llama 3B, the generated programs match the original neural attention heads with average 76% Intersection-over-Union similarity on TinyStories. 12% of heads are matched above 90% IoU.

This is not a heuristic approximation. You can delete the original neural attention head entirely, drop the 12 line Python function in its place, and the model will still run.

Replacing 25% of all attention heads across the model incurs only 16% average perplexity increase. Downstream QA performance remains within measurement error.

Let that land. One quarter of the compute inside three standard production models can be replaced right now with human readable, debuggable, executable code. No fine tuning required.

What attention heads actually do

Most of the extracted programs are boring. That is the good news.

31% of heads implement exact previous token offset lookups. 18% match punctuation boundaries. 11% look for closing bracket pairs. 7% count absolute sentence position.

There are no mysterious emergent functions. There are no alien concepts. Almost every attention head is implementing a trivial string operation that any junior engineer could write in ten minutes.

We spent half a decade speculating about the hidden intelligence of attention. It was just for loops and string indexing this whole time.

Pruning stops being guesswork

If most heads are trivial redundant operations, we should be able to remove them.

Every existing pruning method works the same way. Assign each head an importance score. Sort. Delete the lowest N.

This has always failed badly at high compression ratios. Everyone knew it. No one admitted the core mistake: heads are not independent.

You do not evaluate members of a team by ranking each person in isolation. You select for complementary function.

CAHP: pruning as graph selection

Complementary Attention Head Pruning fixes this.

CAHP does not rank heads. It builds a graph where edge weight is the mutual information between output of two heads. It then clusters this graph, and selects exactly one representative head from each cluster.

It does not accept a pruning ratio as input. It runs until adding another cut causes a sharp drop in marginal performance, then stops. No manual hyperparameter tuning. No retraining required.

On MNLI at 70% head pruning, CAHP retains 92% of original model performance. The next best baseline retains 78%. At 80% pruning the gap opens to 17 percentage points.

Most importantly CAHP does not exhibit the proximity bias that broke every prior method. Gradient based pruning almost always preserves heads in the final 3 layers and deletes everything from the middle of the network. CAHP retains 62% of its selected heads in layers 4 through 12.

We have been throwing away the most important parts of the model for five years because we used the wrong selection metric.

The geometry no one was looking for

None of this work lined up with existing theory because all our existing theory was wrong.

For ten years the standard intuition was: during training, the model concentrates useful information into a small number of high variance directions. The rest of the dimensions are unused noise.

Every pruning method, every distillation method, every probe was built on this assumption.

It is exactly backwards.

TGO-I: what training actually does to representations

Transformer Geometry Observatory is the first systematic, unbiased measurement of representational geometry through the full training run of a ViT.

They did not test hypotheses. They just measured every standard spectral metric, at every layer, every 100 training steps.

Training does not concentrate variance. Training spreads it.

Effective rank increases monotonically for every layer through the entire training run. Spectral anisotropy drops. Spectral entropy rises. Variance is progressively redistributed evenly across every available dimension.

The CLS token, which everyone assumed was a tight compressed summary, has the highest effective rank, flattest eigenspectrum and lowest anisotropy of any representation in the entire network.

This is not a minor result. This invalidates almost every theoretical explanation of transformer training published before 2026.

This is also why all naive pruning failed. We were systematically cutting the dimensions the model had just finished using.

GrapNet: the end of fixed tensor architectures

All of the above results point at one uncomfortable conclusion. The fixed dense tensor is a terrible substrate for the computations transformers actually run.

We have been running sparse graph programs on top of dense tensor hardware. We have been paying for 100% of the compute to run 20% of the actual logic.

GrapNet does not try to build a better transformer. GrapNet builds the substrate that transformers have been emulating badly this whole time.

In GrapNet the graph is the architecture. Every node holds explicit references to its children. Delete an edge and the corresponding parameter slot is removed. No masking. No zeroing. It is gone.

You can freeze a subgraph. You can audit execution path. You can edit connections while the model is running. You can dump the entire active structure as human readable graph at any time.

This is not a benchmark paper. The authors did not run GLUE. They built a programmability stress test. On continual learning benchmarks GrapNet outperforms dense MLPs of twice the parameter count. That is just the side effect.

The point is that you no longer have to reverse engineer the graph after training. You can just look at it.

What this means for production ML

None of this is science fiction. Every method described in these four papers works today on standard production models.

You can go run the attention synthesis pipeline on your fine tuned Llama 3 this afternoon. You can prune 60% of the attention heads with CAHP this week. You will get a smaller faster model that behaves almost exactly the same.

We are not waiting for some future interpretability breakthrough. The tools arrived. Most people just haven't noticed yet.

The end of the black box

For a long time there was a quiet consensus that transformers would remain permanently unknowable. That their internal operations were fundamentally alien, that we would never get further than correlation and heatmaps.

That was wrong.

We did not need smarter probes. We did not need bigger theory. We just needed to stop guessing and start measuring.

All four papers follow the same quiet radical approach. They do not attempt to explain the whole model at once. They do not claim grand unified theories. They take one component apart. They test it. They rebuild it.

This is engineering. This is how you understand systems.

The black box is open. Most people are still standing outside blinking. Now we get to see what is actually inside.