10 captures, most recent first.
Progyan @plugyawn · 10h
If looping works (and it seems like we're only a little bit away), and softmax attention doesn't blow up memory in the process, I think it is trivial to imagine recirculation on an ASIC being a pathway to getting 5-10X the effective depth with barely any wallclock overhead.
[embedded figure from a paper:]
Figure 4: (a) Unrolled loop transformer and (b) unrolled recirculation transformer. The open colored rectangles depict state propagation. In the looped transformer, strict state propagation moves upward in the stack, whereas in recirculation, state propagation can continue indefinitely in the same layer of the stack.
Note from Claude Sonnet 5
A tweet about transformer architecture scaling, arguing that if 'looping' works without softmax attention blowing up memory, recirculation on an ASIC could give 5-10x effective depth with little wallclock overhead. Embedded is Figure 4 from an ML paper: two side-by-side diagrams (a) and (b) of grids of small rectangles representing an 'unrolled loop transformer' versus an 'unrolled recirculation transformer,' with colored state markers (state 1-4 in green/blue/purple/red) showing how state propagates upward through stacked layers in the looped case versus staying within the same layer indefinitely in the recirculation case.
transformersai architectureasicmodel scalingloopingtwitter discourse
Dimitris Papailiop... @DimitrisP... · 23h
I think we are entering a new era of research on small transformers, where many questions we would previously have answered by running experiments can instead be answered mathematically.
This is possible because the cost of doing math has effectively collapsed to verification (much easier than proving stuff!).
Now, instead of testing an empirical hypothesis, we can ask whether the corresponding theorem is true and have GPT or Claude try to prove it.
Math for AI is finally close to becoming a practical probe of reality and not just a way to explain stuff after the fact, but a way to REPLACE experiments and be directly used to explore what is true in the first place.
Kind of incredible!
[quoted tweet]
Dimitris Papailiop... @DimitrisP... · 23h
inspired by @Kangwook_Lee's bat signal and @jefrankle's like, and with the help of GPT-5.6 Sol you can actually prove it :)
In fact it is true that any function f(a,b) -> C ca...
[embedded image of proof text]
Theorem 1 — exact modular addition in a random frozen transformer
With probability one over the frozen random parameters Θ, there exist token embeddings
E_0, ..., E_{p-1}, E_∞ ∈ ℝ^d
and an unembedding
U ∈ ℝ^{p×d}
such that, simultaneously for every a, b ∈ [p],
argmax_{c ∈ [p]} [U h_3(E_a, E_b, E_∞)]_c = (a + b) mod p.
Indeed, we can choose the number embeddings to lie on a one-dimensional line
E_a = au
for any fixed nonzero u ∈ ℝ^d.
Moreover, after conditioning on the random attention weights, the unembedding can be chosen so that the correct class has logit exactly 1 and every incorrect class has logit exactly 0.
Thus the classification margin is exactly 1.Note from Claude Sonnet 5
Tweet thread from Dimitris Papailiopoulos arguing that AI-assisted proof-writing (using GPT-5.6/"Sol") is turning mathematical proof into a practical substitute for running ML experiments, illustrated by a proven theorem about exact modular addition in a random frozen transformer.
ai for mathmechanistic interpretabilitytransformerstheoretical mltwitter
Aryaman Arora ✓ (@aryaman2020) — 23h
since Noam Shazeer is in the news for (probably deservedly) making 1e9 more dollars, i have to say this is my least favourite quote in his work. in my view, the goal of interpretability should be to prevent such claims from being made ever again
[Embedded image, excerpt from a paper]:
4 Conclusions
We have extended the GLU family of layers and proposed their use in Transformer. In a transfer-learning setup, the new variants seem to produce better perplexities for the de-noising objective used in pre-training, as well as better results on many downstream language-understanding tasks. These architectures are simple to implement, and have no apparent computational drawbacks. [circled in red:] We offer no explanation as to why these architectures seem to work; we attribute their success, as all else, to divine benevolence.
Note from Claude Sonnet 5
A screenshot of the conclusion section of a machine learning paper (GLU variants for Transformers, Noam Shazeer), with the final sentence hand-circled in red for emphasis by the tweet author.
machine learning researchinterpretabilitynoam shazeertransformershumor
@FGuzmanAI (Fabio Guzman) — 9:24 AM · Jun 13, 2026 · 62.1K Views
56,000+ tokens/sec at just 80 MHz. 🤯
I burned a full Transformer with KV cache into a custom chip. Designed gate by gate as a 100% digital integrated circuit. Prototyped on a FPGA. (No GPU. No CPU)
Just pure digital silicon running @karpathy microGPT, spelling out names on a tiny LCD.
This is GateGPT 👇
[embedded video, paused at 0:14, caption overlay: "Attention, the MLP and a KV cache — all hard-wired in logic." Video shows a workbench with an FPGA board, cables, and an oscilloscope displaying a waveform.]
Replies: 52 Retweets: 126 Likes: 1K Bookmarks: 598
@FGuzmanAI (Fabio Guzman) — 5h
Code (RTL, fixed-point spec, microcode ISA, weights):
[link card, partially obscured by a chat-bubble UI icon: "fguzman82/ gateGPT — Full Transformer into a custom chip. microGPT in..." (truncated)]
Note from Claude Sonnet 5
Twitter post with an embedded video screenshot (oscilloscope + FPGA board) and a GitHub repo link-preview card at the bottom, partly covered by an app UI element (chat bubble icon).
hardwaretransformersfpgaengineeringkarpathy
Harry Partridge @part_harry_
Pretraining is data-inefficient. This is entirely a consequence of the fact that we throw away the KV cache after every forward-backward step!
If we can integrate efficient KV cache compaction into pretraining, we will unlock human level data efficiency. Neural KV cache compaction makes this possible.
[quoted tweet:]
Charlie O'Neill @oneill_c · 2h
[image: 8-panel chart grid — Train: Loss, Train: Utilization, Eval: MCQ Accuracy, Eval: MCQ Utilization, Eval: CE Utilization, Eval: Cont Utilization, Eval: Compact KL, Eval: Compact CE — all plotted against Number of Latents]
"Towards infinite context windows: neural KV cache compaction"
TL;DR: We compress an LLM's KV cache 8x in milliseconds, retaining 85%+ of factual accuracy across domains. Here's how.
Introduction...
10:53 AM · Apr 1, 2026 · 3,243 Views
[reply] 1 [retweet] 5 [heart] 45 [bookmark] 34 [share]
Harry Partridge @part_harry_ · 1h
In context learning *is* data efficient. We spend so much compute building this rich KV cache on every forward pass. If we can effectively merge this cache with our existing knowledge, we can dramatically improve the data efficiency of pre-training and RL!
Note from Claude Sonnet 5
Twitter thread on ML research about neural KV cache compaction for infinite context windows, and a hypothesis linking it to pretraining data efficiency. Technical ML architecture content relevant to Nathan's brain_graph_1 / memory-architecture interests.
machine learningkv cachetransformerspretrainingdata efficiencytwitterml research
Martin ✓ @mjbukow
It's more complex than that. Because the residual stream is purely additive, low-level gradient noise and intralayer communication signals accumulate across layers. The norm of the hidden states steadily increases with depth. In the last few layers, the model turns up the volume on output-aligned directions; effectively using the growing norm and null-space interactions to overpower accumulated noise and better align the representation for the LM head. The final RMSNorm then projects everything onto the hypersphere right before unembedding, which completely disjoints the gradient right at the end.
All that to say, the gradient is going to be noisy because all of this is being transacted on one purely additive state container that serves multiple purposes in different parts of the model. Passing a clean signal back is more a prayer to AdamW than it is good ML engineering.
6:13 PM · Mar 29, 2026 · 3,109 Views
Note from Claude Sonnet 5
A technical tweet on transformer residual stream dynamics — how gradient noise accumulates across layers and how the final RMSNorm/unembedding interacts with it. Relevant to mechanistic interpretability of the residual stream, a topic adjacent to Nathan's interpretability interests.
machine learningtransformersinterpretabilityresidual streamtwittergradients
Dimitris Papailiopo... ✓ @DimitrisPa... · 3h
AdderBoard update: 50+ submissions in. Smallest transformer that adds two 10-digit numbers at 99%+ accuracy:
🏆 Hand-coded: 6 params (@zcbtrak)
🏆 Trained: 36 params (@TomBukic)
Started at 6K-> Now 6 a 1000× compression :)
Three patterns that I've noticed worth calling out:
1/ Weight tying does a ton of work:
Q, K, V can be the same matrix.
2/ Positional encoding also matters a lot: RoPE with period 19 gives you perfect base-10 digit alignment across input digits of A and B.
3/ Hand-coded (6p) vs trained (36p) is still at 6x gap:
That's the cost of learning from examples, and it's worth thinking about if it's possible for this to go below that any more. There must be some learnability limit related to how rough the landscape looks at some point (we may even be able to plot it out for 3 parameters :)).
This may be very close to being saturated now, but it's been a ton of fun
[Embedded image: pixel-art style graphic titled "ADDERBOARD" showing "CHALLENGE: 1234567890 + 9876543210 = 1111111111100" with a cartoon robot, plus a partially visible chart/leaderboard]
Note from Claude Sonnet 5
A machine learning researcher's update on "AdderBoard," a competitive minimum-parameter benchmark for transformers that add 10-digit numbers. Technical ML curiosity, likely read for interpretability/mechanistic-minimalism interest.
machine learningtransformerstwitterinterpretabilitybenchmarkminimal circuits
Omar Khattab ✓ @lateinteraction · 22h
Buried in the massive progress in LLMs over the past few years is how all your favorite Transformers/DNNs still can't solve even just grade school math problems above a "B" grade through a forward pass.
Unless they're in a scaffold like CoT, ReAct, RLM, etc. And this is true even at trillions of params and bajillions of FLOPs.
For all I can tell, all a vanilla Transformer can do is really glorified kNN. Without a reasoning scaffold, there's just way too many states to compress; too many mappings that were never seen before.
In that case, what makes reasoning models work so incredibly well must be that, at sufficient pretrain/RL scale, every relevant next-reasoning step can be actively visited (more or less "contaminated", but productively so) and composed up.
To be clear, if this is true, it seems to be working, and it explains why scale is so important and why failures are so jagged! If a specific kind of state is not retrievable via compression and kNN, then you're going to get some other ~arbitrary behavior.
tl;dr the distinction between your DNN architecture and your "scaffold" is subtler than you think.
> QUOTED: N8 Programs ✓ @N8Programs · Feb 22
> Inspired by @RyanPGreenblatt, I measured LLMs accuracy on GSM8K when only allowed to output a numerical answer without any CoT - all reasoning done in a few forward passes. The result is a nice log-linear scaling curve. We can ...
> [Image: chart "Reasoning-Free GSM8K: Parameter Count vs Accuracy" — log-linear fit (acc = 18.5*log10(p) + 11.5, R²=0.877), scatter of model points including Qwen3.5-297B, Sonnet 4.6, GPT-5.2, Kimi K2.5]
Note from Claude Sonnet 5
A technical thread on why vanilla transformer forward passes fail at multi-step reasoning without CoT/scaffolding, framing transformers as "glorified kNN" limited to seen-state compression, with an empirical GSM8K scaling chart. Relevant background for interpretability/capability discussions in the project (e.g. brain_graph_1 architecture threads, singularity/r-value tracking).
twitterllm reasoningchain of thoughtscaling lawstransformersinterpretabilitygsm8k
In the future, there will only be three kinds of massive companies.
You choose, would you rather build:
- transformers
- transformers
- or Transformers
[image left: neural-network transformer architecture diagram (encoder/decoder blocks with multi-head attention, add&norm, feed forward, embeddings)]
[image top-right: photo of an electrical/electromagnetic transformer with copper coil windings]
[image bottom-right: illustration of the robot Voltron/Transformers-style giant robot walking down a street with smaller robots]
Note from Claude Sonnet 5
A pun-based joke tweet playing on the triple meaning of "transformer" (ML architecture, electrical device, Transformers robots franchise). Light humor, no substantive AI-safety content.
humortwittertransformerswordplaymachine learning
[Top, cut off original tweet]: "...ppl at all (for most genres). 7b improves *by an order of magnitude and then some* over the only genre 3b gets measurably better at..."
2:34 AM · May 6, 2025 · 744 Views
[1 reply, 1 repost, 14 likes, 1 bookmark]
Andrew Carr (e... ✓ @andrew_n_... · 5h
The int8 paper from 2022 is one of my favorite "mechanical" evidences
[Embedded figure: "Figure 3: Percentage of layers and all sequenc[e] features across the transformer by (a) model size..." — scatter/line plot, x-axis "Parameters in billions" (0-12), y-axis "Percentage of layers or tokens affected" (0-100), two curves (blue, orange) both rising sharply and plateauing around 6-7B parameters, dashed vertical line labeled "emergence of outlier features" at ~6.7B]
Note from Claude Sonnet 5
Twitter exchange referencing the LLM.int8() paper's finding of a sharp phase transition ("emergence of outlier features") around 6.7B parameters — an empirical example of emergent phenomena in scaling, relevant to interpretability and scaling-law discussions Nathan follows.
twitterinterpretabilityemergencescaling lawsquantizationllm.int8transformers