So welcome to the Deep Dive. Our mission today is to act as your shortcut to becoming well -informed about a truly groundbreaking paper. It's a highly technical paper from the ICML 2026 conference. Yeah, the paper is titled, Learning to Discover at Test Time, and it's authored by this incredible collaborative team of researchers. Oh, it's a massive team. Spanning Stanford, UC San Diego, Together AI, the Astera Institute, and NVIDIA. Right, including lead authors like Mert Uxagonal, Daniel Cochea, and Xinhua Li. I mean, it's a heavy -heading lineup. It really is. And the scope of what they have attempted to prove here is just incredibly ambitious. They are essentially asking if we can build a system that acts more like a real scientist in a lab, right? Yes. Adapting and learning from its immediate environment rather than just acting like a very smart encyclopedia. So here's the hook for you, the listener. How does an AI discover a completely new state -of -the -art solution to a scientific problem? It's a million -dollar question. Literally. To date, we have largely relied on taking what we call frozen language models and just prompting them over and over. But what if the model could actually continue to train while it takes the test? Yeah, what if it could learn specifically from its own failures and its own partial successes on that exact specific problem? In real time. To really understand how they pulled this off and why it matters, we are going to meticulously break down this entire paper. Chapter by chapter. Exactly. We're going to explore the foundational mathematical concepts they tackled. We'll look at some intense GPU engineering results too. And we'll dive into how this applies to biological benchmarks. But most importantly, we will unpack the exact mechanics of how this method actually works under the hood. Right. The method they call TTT discover or test time training to discover. So let's start with a foundational philosophy here. I want to use an analogy from the authors that I think perfectly sets the stage. Think back to tackling a really hard programming assignment in school. Oh, those are the worst. Yeah. If you just try guessing the solution based on the textbook, which represents your initial training data, you're probably going to fail. The problem is just too complex. Exactly. It requires multiple steps, unexpected bugs pop up, and the textbook just doesn't cover this specific edge case. So what do you do? You have to try. You have to fail. you have to look at the error messages. Right. You learn from that specific failure and you actually update your own internal understanding of the concepts right then and there. That iterative process is the core of human problem solving. But to understand why that represents a shift in AI, we need to clarify what a frozen model is. Let's define that for everyone. When an AI company spends tens of millions of dollars and months of computing time training a massive large language model, they eventually have to stop. They can't train it forever. Right. At that point, the internal parameters, the billions of weights and biases that define the network are locked in place. They remain fixed. So when you use a standard chatbot, you are interacting with a frozen model. Yes. Its brain is essentially frozen in time. It can't learn anything fundamentally new about the structure of reality once that training run ends, right? Well, I wouldn't go quite that far. And we have to be very careful with that framing. Oh, really? Yeah. It's a common misconception that a frozen model is stuck. and cannot produce anything novel, or that its next attempt just ignores previous results. But if the weights are frozen, how does it adapt? Through what we call in -context learning. OK, what does that mean in practice? By using large context windows and providing external tools like calculators or web search, giving the model feedback from a code compiler. Oh, so the prompt itself changes. Exactly. Frozen models can and absolutely do produce novel breakthrough solutions. Their internal weights remain fixed, but their prompt gets updated with the new context. So if it writes a piece of code and the code fails, the error message just goes right into the prompt? Right. The model reads the prompt, understands the error based on its preexisting knowledge, and generates a new attempt. Ah, I see. So it's not like a frozen model has zero probability of generating something it doesn't already have memorized. Not at all. It can synthesize new ideas within the prompt space. It's vital to clarify that a frozen model is highly capable of generating something new. So the TTT discover authors aren't saying frozen models are useless for discovery. Exactly. They are presenting experimental advantages of their new method, not establishing some mathematical impossibility theorem about frozen models. In fact, later on, we'll see the paper's own purely frozen baseline model achieve some remarkable stuff on its own. It did. That's a great distinction. The frozen model is like a genius locked in a room. You slip notes under the door to give it feedback, and it sends brilliant answers vibe. But its underlying personality and deep structural knowledge isn't changing. Right. So if frozen models are still highly capable, what exactly is the TTT Discover approach doing differently? TTT Discover takes reinforcement learning, or RL, and runs it directly inside the environment defined by the single test problem you want to solve. Instead of just updating the text in the prompt window? Yes. It is literally executing gradient updates on the model's internal weights based on its experience with this one specific problem. Okay, let's slow down and mechanicalize that. Walk me through the actual loop. I give the AI a math problem. What is step one? Step one. The model generates an action. In the context of scientific discovery, that action is typically writing a piece of Python code. Or a heuristic algorithm or a mathematical proof, right? Exactly. So it writes the code. Then what? Step two, the environment executes that code, like a Python interpreter actually runs the script. Okay. And what does that execution do? It produces a new state. And crucially, it produces a continuous reward signal based on how well the code performed. What kind of reward? Like, did it compile? Yeah, did it compile? Did it get closer to the mathematical bound we are searching for? Did it run faster than the previous attempt? So it basically gets a score? Yes, a highly specific numerical score. Then comes step three, which is the big differentiator. OK, lay it on me. TTT Discover takes that specific experience, the state, the action, and the reward, and it performs a gradient update. It actually adjusts its own weights? It mathematically adjusts the internal weights of the neural network to make the model more likely to generate high reward code in the future. Wow. It is literally rewiring its own brain to become an expert at the one specific test it is currently taking. That's exactly what it's doing. Hold on. Updating a massive language model sounds incredibly computationally expensive. It usually is. Right. If I have a 120 billion parameter model and I'm updating its weights. every time it tries to write a line of code, wouldn't that cost millions of dollars? If they were doing full parameter fine -tuning, yes. It would be prohibitively expensive and incredibly slow. So how are they doing it? We need to look at the specific computational cost and scale they report in the paper because it's remarkably efficient. The implementation uses a finite budget. How finite? Exactly 50 training steps. Just 50? Yes, just 50. That seems tiny. At each step, they generate 512 rollouts or attempts from the model. OK, so that's a fair amount of attempts, but still, updating the whole model? No, crucially, they don't update the whole model. They use a technique called Rank32Laura. Which stands for low rank adaptation, right? Exactly. Applied to the OpenAI GPT -OSS -120B model. Exactly. I've heard of Lora, but let's translate that for the listener. What is it actually doing physically to the model? Think of it this way. Imagine you have a massive comprehensive textbook. That's your 120 billion parameter frozen model. Okay, heavy textbook. Instead of erasing and rewriting the printed pages of the textbook, which takes forever, Lora is like slipping a few transparent sheets of plastic over the pages. Oh, and you write your new specific notes on the plastic. Exactly. You freeze the main model's weights entirely, and you just inject a very small set of trainable matrices, the transparent plastic, into the network. So when the signal passes through the brain, it hits the massive frozen knowledge base, but then gets slightly tweaked by these small, highly specialized LoRa layers. Yep, layers that are rapidly learning how to pass this specific test. That is a perfect way to visualize it. I imagine this drastically reduces the compute required. It does. In total, over the entire discovery process, they are doing 25 ,600 rollouts. That's 50 steps multiplied by 512 rollouts per step. Right. We're not talking about thousands of gradient updates to hundreds of billions of parameters. And what does that actually cost in cold hard cash? Because cheap in AI research can still mean like more than my mortgage. The research cost they report was roughly $500 per problem run. Wait, $500? Yes, using the Tinker platform. That is wild. Now I have to emphasize, this is a reported research cost for this specific experimental setup. Right, it's not consumer pricing. Exactly. It is not some universal guaranteed retail price for generating scientific breakthroughs. You can't just hand a server $500 and expect a Nobel Prize. Sure, sure. But what it proves is that the concept is computationally accessible. It's not limited to some massive cluster running for six months. Exactly. $500 to potentially find a new state -of -the -art solution to a math problem that has stumped humans for decades? It's mind -blowing. But here is where my mind goes immediately. If they are just using reinforcement learning to update these LoRa weights, why not just plug in standard RL algorithms? Like PPO or GRPO? Yeah, the algorithms that companies already use to train chat models to be helpful and safe. Why not just use those? That touches on the core theoretical contribution of the paper. This is where we transition from merely what the system does computationally to how it fundamentally alters the mathematics. How so? Standard RL algorithms like PPO are designed with a very specific overarching goal. They aim to maximize the expected reward. Expected reward meaning? Like the average outcome. Essentially, yes. In Standard RL, you are looking for a policy, a way of behaving, that performs robustly and reliably across many, many different states and deployments. You want the model to be consistently good. Right. OK. Let me use an analogy here to see if I'm tracking. Maximizing expected reward is kind of like a major restaurant franchise trying to design a menu. OK. I follow. They want to make sure that every single dish on that massive menu is a safe, consistent B+. You want every customer to have a decent meal. Right. Whether they order the burger, the salad, or the pasta. Exactly. You heavily penalize a recipe that sometimes produces a masterpiece, but often starts a fire in the kitchen. That's a great analogy. Standard RL wants to raise the floor of performance. Right. But scientific discovery doesn't care about the average. It doesn't care about raising the floor. No, it doesn't. It only cares about finding one single Michelin star dish. You just need the one absolute best solution that beats the current state of the art. That is the goal of discovery. It cares if the other 25 ,599 attempts were terrible burnt messes in the kitchen. If attempt number 25 ,600 solves the math problem, you win the Nobel Prize. You're touching on a crucial distinction, though I must Carefully note that optimizing for expected reward doesn't inherently minimize variance in all mathematical setups. Oh, it doesn't. No, and it doesn't always strictly penalize risk. It's simply an average objective. However. However. The authors correctly identify that in the context of scientific search spaces, maximizing average performance is often very poorly aligned with finding one exceptional outlier solution. Makes sense. If your model spends all its computational budget learning how to safely generate mediocre, compilable code, it might never take the wild, chaotic leap required to find a genuine breakthrough. So how does TTT Discover fix that? How do they fundamentally change the math to tell the AI, forget being safe, go exclusively for the Michelin star? They introduce what they call an entropic objective. Entropic objective. OK. How does that work? Conceptually, the math works by exponentially reweighting the rewards based on a tuning parameter called beta. Exponentially reweighting. OK, so normally if attempt A scores a 5 and attempt B scores a 10, attempt B is twice as good. Right. How does exponential reweighting change that? Instead of treating the rewards linearly, where a 10 is twice as good as a 5, the exponential function heavily skews the focus. Excuse it, how? Under an entropic objective with a high beta, that 10 isn't just twice as good. It might be treated as a thousand times more important than the five. Oh, wow. The authors introduce a mechanism called adaptive beta. The system doesn't use a fixed exponential multiplier. It changes. Yes. It sets the beta parameter adaptively for each initial state. And it does this by strictly constraining something called the KL divergence. KL divergence. I feel like I see this term everywhere in AI papers. Let's translate that for the listener. What is it actually measuring? Simply put, callback Liebler divergence, or KL divergence, is a mathematical measure of how much one probability distribution differs from another reference distribution. But does that guarantee it won't break? No, and we need a strict qualification here. This KL constraint is not some magic theorem. that guarantees monotonic improvement. Meaning it doesn't guarantee the model gets strictly better every single step. Right. It doesn't guarantee complete stability, and it certainly doesn't guarantee perfect exploration of the problem space. But remember, the model is generating 512 rollouts per step. That's a lot of attempts. It is. It's building a massive tree of possible solutions. How does it decide which of those previous partial solutions it should actually build upon for the next step? It can't explore all of them, obviously. Right. Does it just pick the one with the highest score and keep going? If it only picked the highest score, it would get trapped in local optima. Local optima? It means it would climb the nearest small hill and never realize there's a massive mountain right next to it. Oh, it would get stuck on a decent idea and ignore the great ones. Right. To solve this, TTT Discover uses a search subroutine inspired by a well -known algorithm called PUCT. PUCT. That stands for predictor upper confidence bound applied to trees, right? Yes. It sounds like something from AlphaGo. Good catch. It is heavily related to the Monte Carlo tree search used in systems like AlphaGo. Oh, cool. It is a state selection rule designed to carefully balance exploiting known good solutions and exploring new uncertain ones. So how does the math work for that? The rule in this paper breaks down into three specific mathematical components. Let's break them down. What's the first component? First, it looks at the maximum reward among a state's children. OK, meaning what? Basically, it asks, when we explored down this specific branch of code previously, what was the absolute best score we eventually hit? Oh, so it looks at the empirical ceiling of that path. Exactly. OK, that's the exploitation part. It favors paths that have already proven they can hit high scores. What's the second component? Second, it uses a prior that is proportional to the state's reward rank. in the replay buffer. Meaning, if a state itself scored really high, it gets a boost? Exactly. Regardless of the children, if a specific state scored very highly compared to everything else the model has ever tried, it gets a boost in probability of being selected again. High reward states get favored. Right. Makes sense. And the third, because right now it still just sounds like it's favoring the winners. The third is the crucial counterbalance. Okay. It's an exploration bonus based on expansion counts. How does that work? The formula heavily boosts the selection probability of states that have a low visitation count. Oh. So the exploration bonus forces the system to look at paths it has neglected. Exactly. It's the algorithm saying, hey, you've completely ignored this weird, mediocre piece of code for 10 straight steps. Maybe there's a breakthrough hidden behind it. Go expand it once just to see. Precisely. It encourages visiting under -visited states to prevent the system from getting tunnel vision. That's really smart. Now, we must ensure it is entirely clear to the listener that this is a mathematical heuristic rule. It encourages exploration, but it does not guarantee exploration of the entire expanding tree of possibilities. Because the tree is just too big, right? Right. With only 50 steps and 512 rollouts, the tree of possible code combinations is infinitely larger than the compute budget. So it's just making smart bets. Exactly. And importantly, there is no separate smaller neural network predicting this prior, which is how some other systems work. Oh, it's just a raw mathematical calculation. Yes. In TTT Discover, it is strictly a mathematical rule calculated directly from the observed rewards and the visitation counts in the buffer. It's elegant and computationally lightweight. Very lightweight. OK, so let's summarize the theoretical engine we've built here. We have the entropic objective acting as a massive gravitational pull toward extreme successes. Now, we need to connect this beautiful theoretical engine to concrete, verifiable results. And the paper starts in the purest domain possible. Mathematics. Okay, so let's talk about the first mathematical challenge they threw at TTT Discover. Erdos's minimum overlap problem. A classic problem. First off, who is Erdos and why is this problem important? Paul Erdos was one of the most prolific and eccentric mathematicians of the 20th century. He was a wanderer who essentially lived out of a suitcase, traveling from university to university, collaborating on thousands of papers. Sounds like a fascinating guy. He really was. This specific problem is a classic in combinatorial number theory, originally posed back in 1955. Combinatorial number theory. So lots of counting and arranging integers. Humans have been chipping away at this for decades. Have previous AI agents tackled this? Yes. A previous evolutionary search AI called Alpha Evolve recently tackled it. And how did they do? They found an improved upper bound of 0 .380924. And they proved this bound by having the AI construct a 95 -piece symmetric step function. OK, so that was the record to beat. What did TTT Discover do? TTT Discover achieved an even tighter, improved upper bound of 0 .380876. Now, to a lay person, moving the decimal from .3809 to .3808 sounds like a tiny, meaningless difference. It does sound small. But in asymptotic mathematics, moving that decimal point at all is a massive breakthrough, right? Oh, absolutely. It's a huge deal. But here is the crazy part of the paper. It didn't just tweak the previous answer. It achieved this new bound by constructing a 600 -piece asymmetric step function. Yes, 600 pieces. That just sounds so weird and specific. What does that actually mean visually? Think about a step function as a staircase on a graph. It's a piecewise constant function. The value is flat, then it jumps up or down, then it's flat again. Right, like literal stairs. Alpha Evolve's best solution was a staircase with 95 distinct stairs, and it was symmetric. Meaning, if you folded the graph in half, the left side perfectly mirrored the right side. But as an expert, I have to apply a crucial, rigorous limit to our excitement here. Okay, what's the limit? The fact that the AI found an asymmetric solution does not prove that the exact, absolute mathematical optimum to the Erdos problem is asymmetric. Wait, really? It just found a better one. It didn't prove it's the best one. Correct. We have a new best bound, but we do not have a proof of optimality. Ah, okay. Furthermore, this result does not prove that all symmetric constructions are inherently inferior. Oh, so there could still be a better symmetric one out there. Exactly. It is entirely possible that a 10 ,000 -piece symmetric function exists that beats this one. It simply means this specific 600 piece asymmetric function is the best bound humanity or machine kind has discovered so far. Fair enough. We have to separate empirical results from mathematical guarantees. Yes. And we also need to do a quick context check on the frozen models here, right? Because earlier we said frozen models aren't useless. Yes. This is a very important point for the listeners keeping score. The paper includes a purely frozen baseline. Which they call best of 25 ,600, right? Right. This baseline just prompted the frozen 120 billion parameter model 25 ,600 times without ever updating its internal weights. And how did the frozen model do? That frozen baseline also discovered a construction that improved upon the previous Alpha Evolve record. Wow. So even without the fancy test time training, the base LLM was smart enough to push the boundaries of combinatorics just by rolling the dice 25 ,000 times. Exactly. Frozen models are highly capable mathematical explorers in their own right, assuming you have enough compute to sample them extensively. TTT Discover just provided the focus learning required to push the frontier even further than the frozen model could reach. That's the perfect way to summarize it. OK, let's look at the next math problem they threw at the system. Auto -correlation inequalities. They tackled two of these, AC1 and AC2. First, what is AC1? These problems also relate to additive combinatorics. AC1 involves finding the tightest upper bound for a specific convolution inequality. Convolution. I know that from image processing, like blurring an image. What does it mean in pure math? A convolution is a mathematical operation on two functions that produces a third function. It expresses how the shape of one function is modified by the other. Okay, I'm with you. In this specific inequality, mathematicians are trying to bound how large the integral of this convolved function can get under certain constraints. And how did TTT -Discover do? The previous state -of -the -art upper bound was pushed down by TTT -Discover to a new record of 1 .50286. And how did it do that? Because the Erdos -1 was a 600 -piece step function, what kind of monster did it build for AC -1? It generated a massive 30 ,000 piece step function. 30 ,000 pieces. How does an AI even write that? It didn't just randomly guess 30 ,000 different decimal numbers and hope they worked, right? No, definitely not. And this is where we see the model acting not just as a guesser, but as a brilliant algorithm designer. Oh, it wrote an algorithm to solve it. To find these step functions, the AI writes Python code to optimize the function using a technique called linear programming. Okay, linear programming. But a 30 ,000 piece function creates an optimization problem that is far too large to solve naively. If you just hand a standard solver a matrix with 30 ,000 variables and millions of constraints... What happens? The computer will run out of memory or take years to compute. So how did the AI bypass the memory limit? The AI learned through its test time training loop to focus its linear programming optimization only on the constraints that were close to being tight. What does tight mean in this context? Imagine you are trying to pack a suitcase. Most of the clothes fit easily. They aren't pushing against the zipper. Those are loose constraints. OK. But the shoes and the hairdryer are pushing hard against the fabric, threatening to pop the zipper. Those are tight constraints. I love that analogy. So in math, tight constraints are the specific rules that are actively preventing the score from getting better. Exactly. It identified the active bottlenecks in the math and only spent compute on those, which allowed it to scale its function up to 30 ,000 pieces. It wrote an efficient algorithm to solve the math problem. But they didn't win every single challenge, did they? What happened with the AC2 problem? AC2 is another autocorrelation inequality, but the goal here is finding a lower bound rather than an upper bound. And how did it do? TTT Discover reached a lower bound of 0 .959. Which is an impressive number, but... But we must adhere strictly to the facts of the paper. It must be clearly stated that this did not beat the previous state -of -the -art lower bound. Oh, really? The previous record was 0 .961, achieved by AlphaVolv2. So it lost to the older AI on this specific problem. Yes. TTT Discover produced a highly capable result. It got very close, but it did not set a new record for AC2. You know, I actually love that. It is incredibly refreshing to see a research paper publish the near misses and the losses alongside the massive wins. It shows they aren't just cherry picking the one time the algorithm worked and hiding the rest. Exactly. It gives us a realistic picture of the technology's current limits. It is the hallmark of rigorous science. Okay, so we have seen TTT discover, tackle, abstract math. Now I want to transition from abstract integers stretching toward infinity to the literal physical silicon hardware that runs AI in the first place. GPU engineering. Yes. If this model is so smart at optimizing math, can it optimize the very code that makes its own computations possible? Let's dive into GPU kernel engineering. This is a fiercely competitive and critical domain. What exactly is a GPU kernel? A GPU kernel is the low -level code that directly commands the graphics processing unit. It dictates exactly how memory is accessed, how calculations are batched. And how the thousands of tiny cores on the chip communicate with each other, right? Exactly. It is the physical computational foundation of all modern AI. Exactly. And to test this, the authors entered TTT Discover into the GPU mode competitions. Specifically, they targeted the Trimol challenge and the MLA decode challenge, right? So the goal of the GPU mode competition is very simple, right? Write the absolute fastest possible GPU kernel for this specific matrix operation. So how did TTT Discover approach this? What was its breakthrough? The AI, through trial and error, identified that the raw calculation speed, the actual multiplication of the numbers, wasn't the problem. Really? Then what was? The bottleneck was heavy memory input -output, specifically caused by frequent element -wise operations. Okay, translation time. Element -wise operations, that's when you have two lists of numbers, say 1, 2, 3, and 4, 5, 6. And you just add or multiply them straight across, right? Yes. The first number with the first number, the second with the second. It's the simplest math possible. But why is doing on a GPU incredibly expensive? Because the GPU has to constantly read data from the massive slow main memory, the HBM, bring it onto the chip, do the simple addition, and then write the answer all the way back to main memory. Oh, I see. It's like needing to chop 10 onions for a recipe, but you only carry one onion from the pantry to the cutting board at a time. That's hilarious. But accurate. The chopping takes two seconds, but the walking back and forth takes an hour. The memory bandwidth is the bottleneck, not the compute. Perfect analogy. So what did the AI do to fix the grocery trips? It leveraged a programming language called Triton to perform what is known as kernel fusion. Kernel fusion. Marrying the operations together. Right. Kernel Fusion means the code tells the GPU to load a large chunk of data into this super fast on -chip SRAM cache just once. Just once. Then it performs all the necessary element -wise operations, multiplications, and additions while the data is sitting in that ultra -fast cache. Oh. And then it writes it back. Only after everything is completely finished does it write the final result back to the slow main memory. It brought the whole bag of onions to the cutting board. Exactly. Additionally, The AI discovered that it could utilize mixed precision. Mixed precision. What does that mean? It chose to store intermediate activations, the temporary scratchpad numbers, in a 16 -bit floating point format, or FP16. Instead of the standard 32 -bit floats? Correct. By having the size of the numbers it was storing, it literally had the memory bandwidth required to move them around. Further alleviating the bottleneck without destroying the accuracy of the final answer. That is so clever. Very clever. Okay, so it fused the kernels and shrunk the data size. What were the actual results? How fast was the AI's code compared to human engineers? We need to detail the exact hardware testing here to be scientifically precise. Okay, give me the specs. The training process, where the AI was actually running the code, checking the latency and updating its weights, was done exclusively using an NVIDIA H100 GPU. The state -of -the -art chip. Yes. However, to prove the code wasn't just hallucinating a trick specific to one chip, the final evaluation of the generated kernels covered multiple architectures. Which ones? The H100, the older A100, the newer B200, and even the AMD MI300X. And what happened when they ran it on the older A100 chip? On the A100, the model achieved a roughly two -fold speedup over the best human submission on the competition leaderboard. Double the speed. It was double the speed of the best human code. That's incredible. It is impressive. But let's keep our feet on the ground here. OK, reality check. What does this actually mean for the industry? Is all AI about to get twice as fast overnight? No. And I must firmly qualify this result. The twofold speed up is highly task and hardware specific. So it's not a magic bullet. We absolutely cannot imply that this single module speed up is going to exponentially accelerate all downstream AI workloads everywhere in the world. It is a specific win on a specific mathematical operation. That makes sense. Furthermore, we must acknowledge that the official remote evaluation environment for the competition doesn't eliminate every single source of hardware timing variation. Right. Cloud GPUs can have a tiny bit of noise depending on temperature or what else is running on the rack. Exactly. There's always a tiny bit of noise. But nevertheless, across multiple runs, it consistently beat the best human submissions. But wait, this brings up a huge question. If we know that AI is capable of writing good kernel code, Why go through the test time training loop at all? Exactly. Why go through this expensive test time training loop? Why not just take all the best GPU kernels in the world, build a massive dataset, and pre -train the model on that? That is a fantastic question. Just let it memorize how to write fast code, and then it can just do it instantly without needing 50 steps of trial and error. And it is exactly what the authors investigated in Appendix H of the paper. Oh, they did test that. They established what they called a general post -training baseline. And they took the base model and they fine -tuned it extensively on kernel bench, which is a large comprehensive data set of GPU kernel optimization problems and solutions. Okay, so they built a GPU expert model. What happened when they entered that model into the Trimel challenge? Post -training definitely improved the model's baseline capabilities. It improved its ability to write valid, compilable code without syntax errors. But did it win? Crucially, its absolute best runtime still failed to beat the top human submissions. OK, we've seen abstract math and we've seen low -level hardware optimization. Now I want to see how this applies to industrial algorithms and messy real -world data. Let's talk about algorithm design and biological benchmarks. Let's start with algorithm design. To test this, they evaluated the model on past at -coder heuristic contests. What are those? These are famous, highly competitive algorithm engineering challenges where programmers write scripts to solve complex logistical puzzles. They looked at two specific contests, right? What were the challenges? The first was the AHC 039 contest. This was a computational geometry problem about designing the optimal layout for fishing nets in a grid. Fishing nets? Yeah, trying to maximize the catch while carefully avoiding penalties for overlapping or inefficient shapes. Okay, interesting. And the second one? The second was the AHC058 contest, which was a complex scheduling and resource allocation problem involving upgrading production capacity over time to meet shifting demands. Heavy logistics. And how did the TTT Discover algorithm fare against the humans who competed? In both cases, the final algorithm generated by TTT Discover would have scored first place on the leaderboard. First place? But wait, let's be careful with the phrasing here. You said would have. Yes. crucial detail we must state clearly. These comparisons concern past contests evaluated retrospectively. Oh, so this wasn't a live competition. Right. This was not a live ongoing competition win where the AI was competing in real time under the same time constraints against humans. The researchers took the historical data, ran the AI, and compared its final score to the historical leaderboard. Still, beating the historical winning scores generated by top human engineers is a massive validation. It is. But how did it compare to other AIs, like OpenEvolve, which is built for this kind of thing? TTT Discover beat the AI baselines as well, setting new high scores. However, in the interest of a rigorous fairness check, the authors explicitly noted a limitation in their comparison to OpenEvolve. What was the limitation? OpenEvolve relies heavily on prompting. And as it iterated on the algorithms, it suffered from context window truncation. Context window truncation. Meaning the prompt just got too long for the AI's memory. Essentially, yes. Yet evolutionary prompts containing the history of the code grew so large that they exceeded the model's maximum memory capacity. So the beginning of the prompt got cut off. Exactly. This severely limited open evolves performance in the later stages. So while TTT Discover 1, it wasn't a perfectly level playing field against that specific baseline due to memory limits. OK. Let's move to the messiest data of all. Biology. The paper highlights single cell RNA sequencing. This sounds incredibly complex and intimidating. Let's break it down. It is a complex field. They tested the model on the open problems denoising benchmark. Okay, what is single cell RNA sequencing? It is a biological protocol that isolates individual cells and measures their gene expression by tagging messenger RNA with unique chemical identifiers. So it's basically taking a census of exactly what genes are turned on inside a single specific cell. Yes. But the physical and chemical reality of doing this at a microscopic level means the resulting data is incredibly noisy and filled with errors. Why is there so much error? Specifically? It suffers from a massive issue called technical dropout. What drops out? The signal. Sometimes a gene is actively expressing in a cell. It is turned on. But the delicate chemical sequencing process just completely misses it. So the data is wrong. The resulting data matrix that the biologists look at is full of false zeros. It looks like the gene is turned off, but it's actually just a measurement error. Oh, wow. It's like taking a picture of a starry night, but your camera sensor is broken, so half the stars just show up as black pixels. That is an excellent analogy. You need a denoising algorithm to look at the surrounding pixels and guess which black spots are actually supposed to be stars. Exactly. So in the TTT Discover environment, the state the AI is generating is a data processing algorithm written in Python. And what's the reward signal? The reward signal is the mean squared error or MSE score of how well that Python algorithm denoises the biological data compared to a known high quality benchmark data set. How did they set up the scientific method for this? Did they just let it memorize the answers? No, they followed strict machine learning protocols. The TTT discover algorithm was optimized, meaning it underwent its 50 steps of trial, error and wait updates using one specific data set known as the pancreas data set. Okay. And then what? After it finished training, that final algorithm was frozen and then evaluated on two entirely held out unseen datasets. The PBMC dataset and the Tabula dataset. And it won. It beat the existing denoising tools on the unseen data. Yes. It significantly outperformed the baseline. To do this, the algorithm it wrote added techniques like gene -adaptive transform ensembling and low -rank SVD refinement. Okay, we need to unpack those terms. Transform ensembling. Imagine looking at that noisy starry night photo. Transform ensembling is like the algorithm deciding to rotate the photo, flip it, adjust the contrast, make predictions on all those different versions. And then average the predictions together to get a more robust answer. Exactly. It looks at the data from multiple mathematical angles. And SVD refinement. Singular value decomposition. SVD is a complex linear algebra technique, but conceptually, it's a way of compressing data to find the most important underlying patterns while throwing away the random static. Oh, I see. The AI essentially wrote a script that said, find the core mathematical shape of this cell's behavior and use that shape to fill in the missing zeros rather than just guessing randomly. And this was better than what humans were using? This approach improved upon the well -known magic algorithm that was the previous standard in the field. This result is evidence of the algorithm's benchmark performance. It strictly does not prove broad biological validity for downstream medical tasks. But it fixed the data. We absolutely cannot claim the model does or doesn't know what a cell is. It doesn't have a PhD in biology. It is a language model optimizing Python code to minimize a mathematical loss function called mean squared error. Right. It just sees a matrix of numbers and a score that goes up or down. Exactly. Better numerical scores on a mean squared error benchmark do not establish biological truth by themselves. Sometimes an algorithm can get a better MSE score by overly smoothing the data, which might look mathematically clean, but could actually erase a rare vital biological signal that a real doctor is looking for. A biologist would still need to take this AI -generated algorithm, run it on real samples, and validate its findings in a wet lab before we can say it has discovered biological truth. That is a very important distinction to keep this grounded. It's a brilliant math machine doing complex math on a biological data set. It didn't cure a disease, it just smoothed out a matrix better than the last script did. Exactly. We must separate the optimization of a proxy metric from the reality of the physical sciences. Okay, so before we conclude our deep dive, a good scientist always takes the engine apart to see which pieces actually matter. We need to look at the ablation studies in the paper. Yes, the ablations. Ablation is basically the process of turning off different parts of the AI system one by one to see what breaks, right? It tells you what is actually doing the heavy lifting. Precisely. Let's look at the ablation realities. First, what happens if you turn off the entropic objective? The thing that aggressively chases the Michelin star outliers. Right. and replace it with the standard expected reward objective that typical RL uses. Does the whole thing crash? It doesn't crash, but the improvement is just much, much slower. It eventually made progress, but the Entropic objective was clearly the primary driver for rapid breakthrough discovery within the tight 50 -step budget. What happens if you turn off the weight updates entirely, like if you freeze the model, but you let it keep the PUCT search algorithm and the buffer of past states? In this specific setup, it stagnates. Really? Even with the smart search? Without the gradient updates altering the internal weights, the search process just couldn't break through the performance ceiling. It got stuck rearranging its existing ideas rather than synthesizing a fundamentally better one. Now, what about that complex PUCT search rule, the one bouncing the child rewards, the historical rank, and the exploration bonus for unvisited states? What if we remove it? Yeah, what if you replace that intricate math with something really simple like epsilon greedy reuse? Epsilon greedy is a classic algorithm. It basically means 90 % of the time just pick the absolute best state from the buffer, but 10 % of the time pick a completely random state just to see what happens. Right, it's the most basic form of exploration. Does using that break the TTT discover system? This is a fascinating correction to a common assumption. You might think losing the fancy PUCT rule would destroy the system's efficiency. I assumed it would. But the paper clarifies that simple epsilon greedy reuse actually works reasonably well. Really? Just occasionally picking random things works. Yes. Especially if the model happens to stumble on a lucky kernel or a good heuristic early on in the search process. Oh, because if it finds a good path early... Epsilon Greedy just exploits it heavily. Exactly. And the weight updates do the rest. It is certainly not a catastrophic failure to use a simpler search heuristic. So the search rule helps, but it's not the secret sauce? The PUCT rule is more mathematically robust across many runs, but the learning objective is the true star of the show. That's funny. Sometimes simple random exploration is good enough if you have a powerful learning engine behind it. But here's the big question, one I have been wondering this whole time. Catastrophic forgetting. Ah, the bane of continual learning. Right. If the model spends 50 steps aggressively obsessing over a GPU kernel. Literally changing its internal weights to become the world's absolute best Trimal GPU coder. Right, focusing exclusively on memory bandwidth. Does it forget how to do basic math? Does it overwrite its general knowledge base to make room for the GPU stuff? It's a very valid concern. When neural networks learn new things, they tend to catastrophically overwrite old connections. So did they test for it? The researchers ran the exact experiment to test this. They took a TTT Discover checkpoint that had been heavily trained and updated on the ERDOS math problem. Okay. And they took another checkpoint that had been fully trained on the Trimol GPU problem. Then they cross -evaluated them. They tested the GPU optimized model on the AC1 and AC2 math tasks to see if its math skills had degraded. Exactly. And? Did the GPU model forget how to do math? The result was that no significant catastrophic forgetting was observed. Wow. The models retain their baseline capabilities on the alternative tasks despite being heavily optimized for a single unrelated problem. Okay, speaking of the 120 billion parameter behemoth that requires massive data center GPUs to run, does this TTT discover method only work on those massive models? The authors tested much smaller base models to answer that exactly. They tested QUIN 3 8B and QUIN 3 4B models on both the air -dose math task and the Trimol GPU task. An 8 billion parameter model is tiny. You could run that on a high -end laptop. How did it do? The results were mixed, but highly encouraging. Even the tiny 8B model, when equipped with TTT Discover, matched or beat some previous state -of -the -art AI methods in the combinatorial math problems. That is incredible efficiency. However, we have to note the limits. The performance of the smaller model severely degrades on the complex coding tasks like the Trimol GPU kernel. Why is that? It seems that writing optimal GPU code requires a much higher baseline of general coding intelligence and syntax understanding that the smaller models just don't possess yet. Ah, I get it. You can't test time train a model to be a genius if its baseline is too low to understand the feedback. Exactly. You can't teach me quantum physics in 50 steps if I don't know algebra yet. That makes sense. Okay, one last point on fairness, the cost -matched baseline. This is an important one. If TTT Discover is taking extra compute to calculate gradients and update weights, is it really fair to compare it to a frozen model that just generates the same number of rollouts? That was a major concern. Right, because TTT Discover used 25 ,600 rollouts plus the heavy computational cost of backpropagation and training, the frozen baseline just used 25 ,600 rollouts. That's not equal dollars spent. The authors address this potential critique directly. So they compared TTT Discover against a best of 58 ,880 frozen baseline. Exactly. And did giving the frozen model double the attempts help it win? No. Scaling the frozen sampling beyond 25 ,600 yielded little to no improvement. Okay, let's zoom out and summarize the incredible breadth of this paper. We have seen an AI bound the convolutions of 30 ,000 -piece step functions by identifying active mathematical bottlenecks. We have seen it leverage Triton to fuse GPU memory operations and double the speed of human engineers on an A100 chip. We've seen it write logistics algorithms to design phishing nets and Python code to denoise complex RNA sequencing data. And it did all of this not by memorizing a textbook, but by continuously updating its own brain during the test. all for roughly $500 of compute per problem. It is a profound demonstration of test time reinforcement learning applied successfully to verifiable, continuous reward scientific problems. It is a major step forward. But I want to leave you, the listener, with an open, lingering question. This is derived directly from the source's future work section and the very nature of continual learning we discussed. That's a big question. We know the model didn't suffer catastrophic forgetting, but what... if anything, transfers to a new problem. This is the absolute frontier of artificial intelligence research. Great. If you use test time training on an LLM to discover a new Erdos bound and it succeeds, did it actually learn a meta skill about mathematical exploration? Does a model that just optimized a GPU kernel become intrinsically better at general algorithm design? Yeah, like if I handed a completely different math problem the next day, does it start from a higher baseline because it learned how to discover? Or is all that learned value completely locked away in the specific context of that one single problem? That is the open question. We must distinguish what has actually been proven here today. We have an improved solution for specific tasks. We have an improved mathematical bound. And we have a general algorithm, TTT Discover, for finding them. But the proof of whether the AI can truly internalize the abstract art of discovery itself, whether it can carry the intuition from one breakthrough into a completely unrelated field the way a human scientist does, remains an open, unproven frontier. The paper does not conclusively settle that question. Thank you so much for joining us on this deep dive into the mechanics of discovery. Keep questioning the results, keep exploring the mechanisms, and we will see you next time.