
So Deepmind dropped AlphaEvolve - a Gemini powered agent that uses LLMs to evolve better algorithms. Think matrix multiplication, fast attention... basically, a nerd paradise.

I was awestruck. Sat frozen for an hour. Then I did what any sane person would do.

Opened ChatGPT and asked, "how was it built?"

Crickets.

Turned out Deepmind didn't release any details. No code. No paper. Just buzzwords like "evolutionary search."

Fine. I'll do it myself. (Thanos aaaaaahhhhh)

## Descent into Genetic Programming

Found the Field Guide to Genetic Programming. Breezed through the essentials:
- Population of programs
- Fitness functions
- Tournament selection
- Crossover (ignored, obviously)
- Mutation (my true love, and also what AlphaEvolve used)

Also went down a rabbit hole on Pareto fronts and NSGA-II. Multi objective optimization sounded cool and made me feel like I was doing science.

## First Attempt: Fast Fourier Foolery
Whipped up a script to evolve Fast Fourier Transform implementations.
- Objective? Speed
- LLM? GPT-4.1
- Result? It got faster

...but only because it returned the input. No FFT. Just `return a`.

I stared blankly. Then punched myself in the face. Deserved.

## Second Attempt: Accuracy enters the chat
Added accuracy as a second objective. Now we're doing real evolution right?

Wrong.

Ran 50, 100, 200 generations. Nothing improved. The LLM was spitting garbage, sometimes not even valid python. Despite giving it function signatures and warm hugs.

Then I found the `prediction` parameter in the OpenAI's API. You can nudge the LLM to follow a previous example. So I fed it that last mutation. It helped. A bit.

But now it was mostly just rediscovering slightly better existing solutions. Maybe deepmind ran theirs for days. I ran mine for a few minutes and went to bed defeated.

## Can you see the Matrix?
New day, new dumb idea. Let's evolve matrix multiplication instead.

Started with GPT-4.1 making freeform mutations.

Results? Errors. Broken logic. Code that didn't even run. Great job, me.

So I enforced mutation strategies. Real ones:
- Reorder loops
- Apply loop tiling
- Add blocking
- Vectorize inner loop

Finally got some good mutations.

But guess what? Every candidate just used `np.dot` or `a@b`.

I had been reward-hacked hard.

Every single one of them discovered that if you just delegate to numpy, you win the benchmark. Technically correct. Ethically illegal.

So I banned the cheats. No `np.dot`, `a@b` and `np.einsum`. Just you, me, and raw loops.

And then it worked. Slowly, painfully, but it evolved a matrix multiplication routine faster than the seeds and didn't cheat.

I almost cried.

## Cursed Implementation Details
Here's what this Frankenstein system actually does:
- Maintains a population of matrix multiplication implementations
- Mutates them via GPT-4.1 using one of many predefined strategies
- Uses a multi-objective fitness function
  - Speed
  - Accuracy
- Runs NSGA style pareto selection with crowding distance to keep diversity
- Ages individuals and replaces them with mutated offspring + random immigrants
- Evaluates each candidate via importlib, runs it on benchmark sizes 128x128 and 256x256, and filters garbage.

Here's the code if you want to read it, clone it, run it, or regret your life choices: [GitHub](https://github.com/think-a-tron/evolve)

If you see me doing crossover next week or trying to evolve merge sort, please stop me. This rabbit hole has no end.

Kthnxbye.


Replicating AlphaEvolve and getting punched in the face


A few weeks ago, if you'd asked me what "advantage" means in reinforcement learning, I'd probably have just shrugged. Today, I'm casually dropping terms like Group Relative Policy Optimization (GRPO) as if I've known them forever—and somehow built a decent physics solver using Large Language Models (LLMs) along the way. All this happened over a couple of weekends and cost me less than what you'd spend on a pizza night.

### Step 1: Getting Friendly with RL

It all started with DeepSeek’s paper on **GRPO**, a clever trick that optimizes policy without a separate value network—basically, just pick the best from a bunch of actions and reinforce that. But first, I had to figure out what the heck "advantage" actually meant.

Enter Hado van Hasselt’s DeepMind RL lectures. Seriously, this guy's explanations are the gold standard—clear, practical, and somehow entertaining enough to keep my attention through math.

### Step 2: HuggingFace's TRL to the Rescue

Then came HuggingFace’s **TRL library**, packed with user-friendly trainers and some fancy plugins like vLLM for faster inference, plus Liger-kernels and Flash Attention for extra speed. Suddenly, everything felt doable—and fast.

### Step 3: The Initial Struggle Was Real

My first idea was to keep it simple, inspired by DeepSeek’s R1-Zero—solve a physics problem, get it right, earn a +1 reward. Sounds easy, right? Nope. Turns out my base model (Qwen3-1.7B) couldn't handle even the basics reliably, so it was back to the drawing board.

### Step 4: Fine-Tuning (and Some Hope)

To beef things up, I curated about 1,500 physics problems across multiple domains like electromagnetism, acoustics, and kinematics—you know, the usual physics suspects.

Next, I gave my struggling Qwen model a crash course in physics via supervised fine-tuning (SFT). In just about 20 minutes on a single H-100 GPU, the model’s performance drastically improved—like cramming before an exam and actually remembering stuff. Loss dropped impressively from 0.7 down to around 0.2-0.3.

### Step 5: One-Shot RL with GRPO (Magic Happens!)

With a slightly smarter model in hand, I moved onto RL—this time with the cool-sounding GRPO technique. Inspired by the idea of "one-shot RLVR" (sounds fancy, right?), I chose a medium-difficulty problem—not too tough, but enough to challenge the model.

Reward scores shot up dramatically, from a measly 0.05 to 0.8 within just 70 iterations. And just like that, over a weekend and about \$10 later (half on dataset prep, half on GPUs), my LLM physics solver was up and running.

### Check it Out

You can actually play with this physics solver now—it's on HuggingFace: [think-a-tron/raman-01-1.7B](https://huggingface.co/think-a-tron/raman-01-1.7B).


Physics and LLMs Can Be Friends?


Reinforcement Learning has emerged as a compelling and powerful method for training agents to make decisions, often surprising humans with moves that initially appear counterintuitive, risky, or outright baffling. Yet, these seemingly insightful choices often lead to exceptional outcomes, driven purely by an agent's relentless optimization of rewards.

But this raises a deeper, philosophical question: Are RL agents truly exhibiting intelligence, or are they simply highly efficient "reward hackers"?

When humans label something as "intelligent", we imply understanding, a grasp of cause-and-effect relationships, purposeful intent, and meaningful abstraction. An RL agent, however, has none of these. It doesn't understand what a "win" truly signifies beyond a numeric increase in its reward function. It doesn't possess intentions or desires in the human sense; it merely follows gradients in policy space, iteratively tuning its actions to maximize returns.

Yet, before dismissing these agents as merely mechanical, we must reflect: What exactly does it mean when we humans claim to "understand" something? Our sense of understanding is deeply tied to causal reasoning, semantics, and the context of accumulated knowledge. But fundamentally, isn't human cognition also driven by reward signals, dopamine hits that reinforce beneficial actions and behaviors? Aren't we, at our core, sophisticated reward hackers, shaped by millions of years of evolutionary pretraining?

Indeed, unlike RL agents who begin training from a random initialization, humans enter the world pretrained. Evolutionary pressures have finely tuned our instincts, biases, and intuitions over thousands of generations. We effortlessly generalize from minimal examples, reason by analogy, and rapidly adapt to new environments, skills RL agents must painstakingly acquire through immense trial and error.

This juxtaposition offers two intriguing possibilities:

First, perhaps RL agents aren't simplistic but merely at the earliest stages of a long evolutionary trajectory toward genuine intelligence. With additional structures, perhaps they could evolve layers of abstraction, theory of mind, and contextual understanding.

Second, and perhaps more unsettling, maybe humans aren't as profoundly intelligent as we like to believe. Perhaps our consciousness, emotions, and complex social structures are sophisticated forms of reward hacking, layers of storytelling and heuristics built atop basic reward-driven optimization.

Thus, the true tension lies not in whether RL agents are intelligent, but rather how we define intelligence itself. Are we setting the bar artificially high, or are we overlooking the simplicity underlying our own complexity.

In the end, reinforcement learning doesn't just challenge how we build intelligent machines, it compels us to reconsider the nature of intelligence altogether.


Machine Learning

Replicating AlphaEvolve and getting punched in the face

Physics and LLMs Can Be Friends?

You are just a fancy reward function, bro