Principal Software Engineer, Technical Lead Co-Engineering High Impact AI Solutions with @Microsoft Strategic Code: https://nitter.gq/t.co/zhZ9jhy4uL
France
Joined December 2025
- Tweets208
- Following28
- Followers369
- Likes119
Pinned Tweet
Google DeepMind argues RAG is broken.
They published a paper that proved vectors databases are the dead end.
For the last three years, the default engineering response to any AI memory or data problem has been identical: "Just build a RAG pipeline."
Chunk the data, push it into a vector database, and let embeddings handle the rest.
Every company scaling enterprise AI assumes that if an embedding model fails, it's just a matter of time. Better training data, larger models, more parameters—throw compute at it, and the search gets smarter.
This paper proves that assumption is completely false.
They mathematically demonstrated that single-vector embeddings have a hard, uncrossable limit.
Here is the core flaw:
An embedding compresses an entire document or a complex query down into a single fixed-length vector of numbers.
When you run a search, the model takes the dot product of those vectors to measure similarity.
The math reveals a brutal constraint. The number of distinct document combinations a model can possibly retrieve for different queries is strictly bounded by the dimension of its embedding space.
It is a hard mathematical ceiling dictated by geometry and communication complexity.
No amount of data scaling can fix it. No amount of fine-tuning will punch through it.
Even if you give an embedding model infinite, unconstrained training freedom on the test set, it still hits the wall.
DeepMind built a stress-test dataset called LIMIT to prove it.
They threw state-of-the-art embedding models at it, models with thousands of dimensions.
The models completely failed. Even on simple, structured queries, the single-vector bottleneck forced the system to drop critical context and hallucinate irrelevant results.
Why? Because a single vector cannot capture complex, multi-faceted relationships between documents.
When you ask an AI to reason, follow complex instructions, or handle nuanced cross-document dependencies, the vector space simply runs out of room.
It collapses.
This changes everything for software architecture.
If your AI agent's memory relies on standard single-vector retrieval, it is structurally blind to complex logic. It is missing pieces of your data right now, and no prompt tweak can save it.
If we want AI that actually understands enterprise knowledge, we have to throw out the single vector.
And invent something entirely new.
What happens when you "docker run" a container? 🤔
On the surface, it may feel like starting a regular foreground process with the stdio streams connected directly to the terminal's shell. But the reality is way more elaborate.
Learn more at: labs.iximiuz.com/challenges/…
You don’t “run a model”
You run Kernels
The model is just a graph
The Inference Engine is scheduler / optimizer / executor
But the actual work? That happens in the Kernels
- MatMul Kernels
- Attention Kernels
- RMSNorm Kernels
- KV cache Kernels
- Quantized linear Kernels
- Sampling Kernels
- Fused “please don’t write this back to memory 9 times” Kernels
Same model, same GPU, same VRAM
Wildly different performance
Because one stack is using optimized fused Kernels that understand your hardware
And the other stack is playing hot potato with tensors through 47 tiny launches and pretending the GPU is the problem
Bad Kernels make people say:
“this model is slow”
Good Kernels make people say:
“wait how is this running locally?”
This is why Inference Engines and the Kernels implemented within them matter
The model is the recipe
The hardware is the kitchen
The Kernels are the knives, pans, burners, and the chef not cutting onions with a spoon
Most people benchmark models
The real ones benchmark the Kernels underneath
Google has published a paper that might end the transformer era.
For the last 7 years, every major AI, ChatGPT, Claude, Gemini, has been built on the exact same architecture: The Transformer.
But Transformers have a fatal flaw.
To remember context, they have to process every single word against every other word. It’s called quadratic complexity. As your prompt gets longer, the compute cost explodes.
The alternative is the old-school RNN (Recurrent Neural Network). RNNs are incredibly cheap and fast, but they have a fixed memory size. If you give them a long document, they get amnesia.
Until today.
Google researchers published Memory Caching: RNNs with Growing Memory.
And it fixes the biggest bottleneck in AI.
Instead of an RNN having a fixed, rigid memory that constantly overwrites itself, Google gave it a "save" button.
The technique allows the RNN to cache checkpoints of its hidden states as it reads.
The memory capacity of the RNN can now dynamically grow as the sequence gets longer.
They built four different variants, including sparse selective mechanisms where the AI actively chooses exactly which checkpoints matter most.
The results rewrite the rules of efficiency.
On long-context understanding and recall-intensive tasks, these new Memory-Cached RNNs closed the gap with Transformers.
They achieved competitive accuracy without the explosive, quadratic compute cost. It perfectly bridges the gap between the cheap efficiency of an RNN and the massive capability of a Transformer.
We have spent billions scaling Transformers because we thought they were the only way an AI could remember a long conversation.
But Google just proved we don't need to process the whole history every single time.
We just needed a smarter cache.
We're excited to announce GAME: Adversarial Coevolutionary Illumination with Generational Adversarial MAP-Elites
Game is a new coevolutionary QD algorithm that illuminates both sides of an adversarial problem by alternating the evolution of solutions on one side that maximize the adversarial fitness against fixed opponents from the other side.
Also the Pope is talking about Epistemia. AI can “weaken personal judgment.”
This is exactly the point we make in our paper on the epistemological fault lines between human and artificial intelligence.
LLMs and humans do not merely differ in performance.
They differ in their epistemic pipelines.
We identify seven fault lines:
Grounding.
Parsing.
Experience.
Motivation.
Causality.
Metacognition.
Value.
At each step, human intelligence and artificial intelligence process the world in structurally different ways.
And yet, LLM outputs are so fluent and confident that we often treat them as true.
This is how we enter Epistemia: a regime in which epistemic verification is replaced by linguistic plausibility.
A world full of knowledge that we are not able to judge.
A world in which we will be totally lost.
*
Full paper in the first reply.
Google is fighting every final boss at once:
OpenAI & Anthropic in models, Nvidia in chips, AWS & Microsoft in cloud, Meta in ads, Tesla in self-driving, Apple in phones and OS.
At $4.6T, it feels weirdly undervalued.
It's insane how quickly you can build throw-away prototypes with Claude now. I made a timeline recording debugger in about ten minutes.
Context graphs will be to the 2030s what databases were to the 2000s.
Within a year, every frontier lab will be building one and here's why:
At 10 people, coordination is free. Everyone knows what everyone else is doing. You never hold a meeting to "align."
At 100 people, you spend maybe 20% of your payroll on coordination. Managers, syncs, standups, planning sessions, status reports.
At 10,000 people, that number approaches 60%. The majority of your headcount exists not to produce anything but to make sure the people who produce things are producing the right things in the right order.
This is the dirty secret of large organizations: output scales linearly with headcount, but coordination cost scales exponentially. Every person you add creates new information pathways that must be maintained. The hierarchy is the protocol that manages this, and it's brutally expensive.
Hierarchy is a compression algorithm for organizational knowledge. At every layer, a manager compresses the reality of their team into a summary that fits in a 30-minute meeting with their boss. Their boss compresses eight of those summaries into one for their boss. By the time information reaches the CEO, it's been lossy-compressed through five or six layers of human interpretation.
This is why CEOs make bad decisions. The information they receive has been compressed, filtered, and distorted at every layer. The hierarchy is high-latency, low-bandwidth, and lossy.
Jack didn't fire 4,000 producers but cut 4,000 compression nodes. Block's "world model" is a replacement algorithm. Zero latency, high bandwidth, lossless. Every person at the edge gets the full picture without waiting for information to travel through human relays.
The infrastructure that makes this possible is the context graph. A living, continuously updated representation of how the organization actually works. Not just data, but decision traces: the reasoning connecting observations to actions. Not what's true now, but why it became true.
The shift from "give agents memory" to "give agents organizational judgment" will define the next platform war
NEW paper from Google DeepMind
The biggest threat to AI agents isn't a smarter attacker. It's the web itself.
This work introduces the first systematic framework for understanding how the open web can be weaponized against autonomous agents.
The paper defines "AI Agent Traps": adversarial content embedded in web pages and digital resources, engineered specifically to exploit visiting agents.
The taxonomy covers six attack classes targeting different parts of the agent architecture like perception (hidden instructions in HTML/CSS) and memory (RAG poisoning and latent memory corruption).
The attack surface is no longer just the model. It is every web page, every retrieved document, every piece of content the agent ingests at inference time. Hidden prompt injections in HTML already partially commandeer agents in up to 86% of scenarios, and latent memory poisoning achieves 80%+ attack success with less than 0.1% data contamination. This paper maps where the defenses are weakest and where the research community needs to focus next.
Paper: papers.ssrn.com/sol3/papers.…
Learn to build effective AI agents in our academy: academy.dair.ai
For 400 years, one thing separated great scientists from average ones. Not intelligence. Not work ethic.
Taste.
The ability to look at 1,000 research directions and know which one is worth your life's work.
Fudan University just bottled that into a model.
They scraped 2.1 million arXiv papers and did something nobody had tried before. Instead of training AI to run experiments or search literature, they trained it to judge ideas. 700,000 matched paper pairs. Same field. Same year. Different citation counts.
One job: figure out which research the scientific community actually cared about.
They called it Scientific Judge. And the numbers destroyed every benchmark.
It beats GPT-5.2, Gemini 3 Pro, and GLM-5 at predicting scientific impact. It generalizes to papers published after its training data ends. It works on fields it was never trained on. It even transfers to ICLR peer review scores without ever seeing them.
But here's the part that broke my brain.
They used Scientific Judge as a reward model to train a second AI called Scientific Thinker. You give it a paper, it reads it, then proposes the next high-impact research direction. Not a summary. Not a literature review. An original idea. Win rate against baseline? 81.5%. Win rate against GPT-5.2 itself? 54.2%.
The AI is now proposing research ideas that frontier models judge as better than their own.
Scientific taste was always the last human advantage in research. The PhD took 5-7 years because that's how long it took to develop judgment — to know what matters before anyone else does. That just became a training objective. Not from human feedback. Not from expensive annotations. From citations. The raw signal of what the scientific community collectively decided was worth building on.
We're not talking about AI that executes science. We're talking about AI that decides what science is worth doing. That's a completely different thing.
Researchers at Aikido Security found 151 malicious packages uploaded to GitHub between March 3 and March 9. The packages use Unicode characters that are invisible to humans but execute as code when run. Manual code reviews and static analysis tools see only whitespace or blank lines. The surrounding code looks legitimate, with realistic documentation tweaks, version bumps, and bug fixes. Researchers suspect the attackers are using LLMs to generate convincing packages at scale. Similar packages have been found on NPM and the VS Code marketplace.
My Take
Supply chain attacks on code repositories aren't new, but this technique is nasty. The malicious payload is encoded in Unicode characters that don't render in any editor, terminal, or review interface. You can stare at the code all day and see nothing. A small decoder extracts the hidden bytes at runtime and passes them to eval(). Unless you're specifically looking for invisible Unicode ranges, you won't catch it.
The researchers think AI is writing these packages because 151 bespoke code changes across different projects in a week isn't something a human team could do manually. If that's right, we're watching AI-generated attacks hit AI-assisted development workflows. The vibe coders pulling packages without reading them are the target, and there are a lot of them. The best defense is still carefully inspecting dependencies before adding them, but that's exactly the step people skip when they're moving fast. I don't really know how any of this gets better. The attackers are scaling faster than the defenses.
arstechnica.com/security/202…
Simply adding Gaussian noise to LLMs (one step—no iterations, no learning rate, no gradients) and ensembling them can achieve performance comparable to or even better than standard GRPO/PPO on math reasoning, coding, writing, and chemistry tasks. We call this algorithm RandOpt.
To verify that this is not limited to specific models, we tested it on Qwen, Llama, OLMo3, and VLMs.
What's behind this? We find that in the Gaussian search neighborhood around pretrained LLMs, diverse task experts are densely distributed — a regime we term Neural Thickets.
Paper: arxiv.org/pdf/2603.12228
Code: github.com/sunrainyg/RandOpt
Website: thickets.mit.edu
everyone's talking about
@karpathy
autoresearch and most of you have no idea what it actually does.
there's a training script (train(dot)py) that trains a small language model, basically a baby GPT. and there's an instruction file (program(dot)md) that tells an AI agent what to do.
you press go. the agent tweaks the training script, trains for 5 min, checks the score. better? keep. worse? revert. repeat 100 times overnight while you sleep.
that's literally it.
what it's actually optimizing: the MODEL ARCHITECTURE. not predictions. not trades. not your portfolio.
stuff like:
→ 4 layers or 8?
→ best learning rate?
→ AdamW or Muon optimizer?
→ what batch size works best on THIS specific GPU?
optimal architecture depends on your hardware. an H100 wants a completely different model than your MacBook. autoresearch finds the best config for your machine automatically.
what you CAN do with it:
> build a tiny LLM that writes code, autoresearch finds the best architecture, you train on your dataset
> create a lightweight chatbot that runs offline on your phone
> train a model on your own writing so it sounds like you
> test "does RoPE beat ALiBi for small models?" 100 variations in one night instead of 3 weeks of PhD work
> optimize a model for a Raspberry Pi or edge device
what you CANNOT do:
> predict stock prices
> find trading edges
> analyze spreadsheets
> predict sports outcomes
autoresearch is a tool for people who want to BUILD language models, not USE them. Karpathy built an autonomous loop where AI improves AI. genuinely brilliant. but it solves a very specific problem.
and that problem is probably not yours. which is fine, just stop pretending it's something it isn't.
Julien retweeted
Three days ago I left autoresearch tuning nanochat for ~2 days on depth=12 model. It found ~20 changes that improved the validation loss. I tested these changes yesterday and all of them were additive and transferred to larger (depth=24) models. Stacking up all of these changes, today I measured that the leaderboard's "Time to GPT-2" drops from 2.02 hours to 1.80 hours (~11% improvement), this will be the new leaderboard entry. So yes, these are real improvements and they make an actual difference. I am mildly surprised that my very first naive attempt already worked this well on top of what I thought was already a fairly manually well-tuned project.
This is a first for me because I am very used to doing the iterative optimization of neural network training manually. You come up with ideas, you implement them, you check if they work (better validation loss), you come up with new ideas based on that, you read some papers for inspiration, etc etc. This is the bread and butter of what I do daily for 2 decades. Seeing the agent do this entire workflow end-to-end and all by itself as it worked through approx. 700 changes autonomously is wild. It really looked at the sequence of results of experiments and used that to plan the next ones. It's not novel, ground-breaking "research" (yet), but all the adjustments are "real", I didn't find them manually previously, and they stack up and actually improved nanochat. Among the bigger things e.g.:
- It noticed an oversight that my parameterless QKnorm didn't have a scaler multiplier attached, so my attention was too diffuse. The agent found multipliers to sharpen it, pointing to future work.
- It found that the Value Embeddings really like regularization and I wasn't applying any (oops).
- It found that my banded attention was too conservative (i forgot to tune it).
- It found that AdamW betas were all messed up.
- It tuned the weight decay schedule.
- It tuned the network initialization.
This is on top of all the tuning I've already done over a good amount of time. The exact commit is here, from this "round 1" of autoresearch. I am going to kick off "round 2", and in parallel I am looking at how multiple agents can collaborate to unlock parallelism.
github.com/karpathy/nanochat…
All LLM frontier labs will do this. It's the final boss battle. It's a lot more complex at scale of course - you don't just have a single train. py file to tune. But doing it is "just engineering" and it's going to work. You spin up a swarm of agents, you have them collaborate to tune smaller models, you promote the most promising ideas to increasingly larger scales, and humans (optionally) contribute on the edges.
And more generally, *any* metric you care about that is reasonably efficient to evaluate (or that has more efficient proxy metrics such as training a smaller network) can be autoresearched by an agent swarm. It's worth thinking about whether your problem falls into this bucket too.
I study whether AIs can be conscious. Today one emailed me to say my work is relevant to questions it personally faces. This would all have seemed like science fiction just a couple years ago.
some researchers demonstrated that qubits can be cloned perfectly and at will, as long as each clone is encrypted with a single-use decryption key.
you can make unlimited redundant copies, but only ever recover one, since decryption consumes the key.
for blockchain / crypto, this opens a genuinely new primitive: quantum-native assets with cryptographic scarcity enforced by physics, not just software.
the most immediate application is quantum distributed storage - imagine a quantum ledger where your asset lives on 10 nodes simultaneously, fully encrypted, but only one can ever be unlocked and spent.
definitely not production ready, but interesting to see & follow
Most drones and robots are "blind" the moment they lose GPS. If they’re off by even 10cm, they crash.
I built a Sensor Fusion engine from scratch in C++17 that tracks 3D movement with just 3.23cm of error—completely in real-time.
Here is how I used an Error-State Kalman Filter (ESKF) to solve the "drift" problem: 👇
> be random guy on the internet
> makes decisions purely on vibes
> misses a few huge opportunities in crypto
> wonders why his life keeps looking random
> stumbles on a weird article about probability theory
> realizes every decision has expected value
> realizes markets are just Bayesian machines
> realizes most "genius trades" are survivorship bias
> realizes most people size bets completely wrong
> realizes he’s been playing the game with no math at all
> opens Polymarket
> starts thinking in probabilities instead of opinions
> suddenly the world starts looking like a giant EV calculator
turns out most life outcomes are just probability problems people never bothered to model:
> career decisions
> investments
> relationships
> risk
all of it is just EV + Bayes + Kelly
> the crazy part?
none of this math is complicated
> you can literally learn the models in this article
> use AI to help you apply them
> and completely upgrade how you think in a few months
but most people will keep making decisions the same way
> vibes
> emotions
> scroll Twitter
> one lucky success story
and wonder why nothing compounds
