I made my agent more capable and it got worse

#ai #machinelearning #python #agents

Builder Journal · ARC Prize 2026

There is a moment in every role-playing game where you load your character with so much heavy gear that they can barely walk. Strongest sword in the game, can't reach the fight. I did the machine-learning version of that this month. I kept making my agent more capable, and the scoreboard kept punishing me for it, and it took me two tries to understand that the upgrades were the problem.

A quick frame, in case this is your first entry in this thread: I'm in the ARC Prize 2026, building an agent that has to learn small games it has never seen, with no instructions. As the benchmark's creator measured it, the hardest part by far is the piece that figures out the rules of a game by experimenting on it. So that piece is where I have been pouring my effort.

The obvious upgrade

The obvious way to make that piece better is to teach it more kinds of games. If it can model three families of puzzle today, teach it a fourth, and it should win more. So I did exactly that. I built support for a new class of game it could recognize and solve, wrote it carefully, tested it, and confirmed the thing I wanted to confirm: the agent now beat a game it provably could not beat the day before. Real, verified, new capability. Not a story I was telling myself, a genuine new skill on the board.

Then I submitted, and the score went down.

Twice

This is the part I want to be honest about, because one bad result is noise and two is a pattern. My agent's attempts to use this theory-building component had already been underwhelming on the real board, landing around 0.05, 0.07, and 0.09 across earlier tries, all of them under the 0.25 my plain, careful agent scores when it does not reach for the fancy component at all. The fourth skill was supposed to turn that corner. Instead the next submission came in at 0.04, the worst of the lot. I had added ability and the number had dropped, again.

So I stopped adding and started counting. I ran a survey across twenty-five of the practice games to see what my agent was actually doing on each one. The shape of it was sobering. It cleanly won five. It correctly recognized five more as hopeless and skipped them. And on most of the rest, it poked and prodded at the game, spent real effort trying to build a theory, and then gave up with nothing to show for it.

The reason, when I finally cornered it

The failure was not in the new skill. It was in the cost of reaching for the skill at all. Every time the agent tries to build a theory of a game, it has to spend real moves poking at that game to test its guesses. On a game it can crack, that effort is an investment that pays off in a win. On a game it cannot crack, the effort is pure loss, spent and gone, and most of the hidden games turn out to be ones it cannot crack.

So every new skill I added had the same hidden effect. It made the agent attempt more games, which meant it spent more effort on more games it would ultimately lose anyway, and paid that toll on every single one. I thought I was buying wins. I was buying more expensive losses. Adding the fourth skill is exactly what dragged 0.09 down to 0.04: more reasons to try, more failed attempts, more cost.

What it means

This is the trap of optimizing the wrong variable. I had been quietly counting how many games my agent could solve, treating raw capability as the goal. The competition does not pay for capability. It pays for net result, and a capability that costs more than it returns is a liability wearing the costume of progress.

The lever I thought I was pulling, make it able to do more, was the wrong lever. The right one is closer to the opposite, and that part I am keeping to myself for now, because it is still live and still my edge. What I can hand over freely is the principle underneath it: more powerful is not the same as better. A bigger toolbox is only an asset if you also know when to keep it shut. I spent weeks adding tools, and the breakthrough, when it comes, is going to be a lesson in restraint, not capability.

Where I'm standing right now

0.25, same as ever, and the plain agent still wears the crown over every cleverer version I have built. The difference is that I now understand why all that added capability never moved the number, which is not nothing. Knowing precisely why a thing fails is the toll you pay on the road to the thing that works.

Next entry: the time I spent two full work sessions reasoning from something I believed about my own code that turned out to be flatly untrue.

More in this series