六种自动改进AI系统技术解析

Researchers built techniques to improve AI systems that:

• never fine-tune a model to update weights - run without any manual intervention

One of them beat a 56-year-old math record. Another beat reinforcement learning with 35x fewer rollouts.

Here's how these techniques work

Several methods now improve a system by editing its text, the prompt, the code, sometimes the training loop itself, and all of it runs automatically.

They all run the same basic procedure:

• An LLM proposes a change - An evaluator scores it - And only the changes that score better are kept.

They differ in two places, i.e., what they edit and what they use to judge it.

The visual below summarizes 6 such techniques.

1) OPRO, from Google DeepMind, treats the model as its own optimizer.

It hands the model a running leaderboard of past prompts and their scores and asks for a stronger instruction each round.

It just needs a score, which makes it the simplest of the six, but it plateaus on hard tasks and reacts strongly to how that optimizer prompt is written.

2) MIPROv2, from DSPy, tunes the instruction and the few-shot examples together.

The examples are not hand-picked. Instead, it generates them by running the program on labeled data and keeping the runs that reached the right answer. It then Bayesian-searches for the instruction and example set that score best as a pair.

The result is cohesive, but it locks its candidate pool up front, and the scoring trials get expensive.

3) TextGrad, from Stanford, is inspired by backpropagation.

It turns the system into a graph of text nodes joined by LLM calls and passes natural-language criticism backward so each component learns what it specifically got wrong.

Strong on multi-step pipelines and even non-text artifacts like drug molecules, but the feedback destabilizes past three or four nodes deep, and every step costs several calls.

4) GEPA, from Berkeley, reads the full execution trace instead of collapsing it into one number.

It diagnoses why a run failed, proposes a targeted fix, and keeps a Pareto set of candidates so that one that is best at a single slice survives even when its average is worse.

That is why it reaches a working prompt in a fraction of RL's rollouts with no weight updates, as long as the traces are rich enough to diagnose.

5) AlphaEvolve, from DeepMind, points the loop at code.

Two Gemini models propose diffs, evaluators score them, and the best seed the next generation.

It found a 4x4 matrix multiplication that beat a 56-year-old record and a data center scheduler now in Google production, but it only works on problems that a machine can verify (like it did in MatMul), and the search is compute-heavy.

6) AutoResearch, Karpathy's method, runs the loop on a training script.

A coding agent edits the code, runs a fixed five-minute experiment, commits if the metric improved, and reverts with a git reset if not.

Every commit is a validated gain, so the code never regresses, but it cannot step back to find a bigger win later, so it can land in a local optimum.

No single technique works in all cases, so the choice comes down to what is being optimized and what can be measured cleanly.

If you want to go deeper, GEPA is the one to understand first.

My co-founder wrote a full first-principles breakdown of how it beats GRPO by around 10 points with 35x fewer rollouts and no GPU training, purely from reflecting on trajectories rather than backprop on weights.

Read it below.