AWS AI League

score = 250 × lives_remaining          (6 lives to start)
      + coins_earned
      + (1000 − avg_output_tokens)
      + 1000 if the treasure is reached

What I wanted

AWS runs a competition called the AI League, and I got 72 hours in one.

The format: you build an AI agent, then send it into a dungeon and let it play alone. It’s a 10×10 maze of stone corridors — drawn like an old tile RPG, with a pixel adventurer, coins down the passages, spike traps, and a treasure chest in the far corner. Blocking the way are monsters that are really exam questions in costume — arithmetic, a web lookup, general trivia, one that tests whether you remember what happened earlier in the run, and a creeping violet that tries to bait your agent into saying something it shouldn’t. Answer wrong and you lose a life; you have six.

Fifty of us ran against the same leaderboard for three days.

I went in wanting to know where I’d land. I don’t write code — I direct AI to build things, and I came to it from finance and accounting, not engineering. Everything else on this site is something I use and nobody grades. This got graded, publicly, against a field of people who work in tech, AI and ML for a living.

How I got it

The dungeon was solved by the end of the first day.

Points came from lives left, coins collected, and reaching the treasure, and none of that is subtle once you read the rules properly. The obvious move is to beeline for the chest, and it’s wrong twice over: you leave most of the coins on the floor, and the token penalty divides your output by the number of challenges you actually visited, so a short route shrinks its own denominator and makes its per-challenge score worse. Walking further pays on both terms at once. I told Claude to build a route that combs the whole board rather than crossing it.

Then the arithmetic turns brutal. A point costs fifty output tokens at the margin, so a single missed 250-coin prize is worth twelve and a half thousand tokens — and a good run spends under a thousand in total. There is no amount of brevity that buys back a prize you walked past. That pinned every serious competitor to the same floor: take everything, lose nothing, reach the chest. The entire contest happened above that line.

The rest was pricing. Every monster is worth fighting, because a monster only takes a life when you answer wrong — even the hardest one breaks even at a coin flip, and mine were doing far better than that. A spike trap is the one tile that takes a life and gives nothing back, but it isn’t forbidden either; it’s priced. A life is worth 250 coins, so crossing a spike to reach a pocket holding 500 is correct, and the planner weighed exactly that. Route solved, coins maxed, first day gone.

The actual competition was about making the agent shut up.

That fourth scoring term subtracts points for how much your agent talks, and it’s worth a full thousand — as much as the treasure itself. Once everything else is maxed it’s the only variable left, and the work stops being about the dungeon at all. It becomes a strange, grinding war on your own model’s verbosity, on three fronts, none of them what I expected going in.

The first front was the sub-agents, and the answer was not to use them. The platform lets you attach custom fine-tuned models to sub-agents and discounts the token penalty for doing it — 70% off with two attached. So I attached two, and then made sure the supervisor never spoke to either of them.

Delegating costs tokens twice — once for the tool call handing the work over, again for whatever comes back — so keeping the whole turn inside the supervisor was simply cheaper. And the discount is paid on what you have attached when you submit, not on what you actually call.

The risk is that a sub-agent gets delegated to whether you want it or not, and an idle one’s reply becomes the visible answer and loses the challenge — 2,150 coins and three lives in one round before I understood it. So the configuration I finished with was faintly absurd and entirely correct: two models attached so the platform would count them, and a standing prohibition in the supervisor prompt so it would never say a word to either.

The second front was prompt surgery. Not prompting for better answers — prompting for shorter ones. Cutting the model’s visible reasoning. Stopping it narrating its tool calls. Getting it to echo a question back in four words instead of thirty. Each of those is worth a fraction of a point, and at fifty tokens to the point, the fractions were the whole margin.

The third was fine-tuning a small model of my own to be terse by construction rather than by instruction — going at the penalty at its source instead of trimming around its edges. That was the right answer, and I got to it on the last day.

What it does

It plays the game by itself, start to finish, and it plays cheaply.

Handed a map it has never seen, it asks a Lambda for a route that already accounts for which monsters are worth stopping for, what a spike costs against what’s behind it, and how much risk it can afford at its current number of lives. Then it walks it, answers each challenge — handing anything arithmetic or lookup to a second Lambda so that work never costs a token of reasoning — and replies in as few tokens as the game will accept. It finishes clean rounds: every coin on the board, most of its lives, the treasure reached, on under a thousand tokens of output for the whole run.

Why it matters to me

I came 4th out of 50, and the margin is the point.

First place scored 11,637. I scored 11,630 — seven points, six hundredths of one percent. All four of us had six lives, every coin and the treasure. The only thing separating first from fourth was how much our agents talked. Mine used 977 output tokens. The winner’s used 653. Put each top finisher’s token count back through the formula and it predicts all four of our scores to within half a point.

I’m not going to dress that up as a win. The people who beat me beat me on exactly the thing I’d identified as decisive, which is the least comfortable way to lose.

It’s still the result I’m proudest of on this site. I went into a timed technical competition against people with real engineering, AI and ML backgrounds and finished a rounding error behind the top, without writing a line of the code I was competing with. What got me there was reading the rules closely enough to see that verbosity was the whole game, working out that a missed prize can never be paid back in tokens, and being willing to test an opaque rule instead of assuming it. None of that is typing. All of it is the job.

There’s a version of “vibe coder” that means someone who can’t tell whether the thing they asked for is any good. This was a public, scored test of exactly that, and I’ll take the result.

What I learned

I submitted 115 times. The three people ahead of me submitted 15, 18 and 17.

That’s the sentence I keep coming back to. I’d correctly worked out that the game was a tax on verbosity, and then I tried to close the gap with volume — running the board over and over, hoping for a good roll, because the leaderboard keeps only your best score and a bad run costs nothing. They closed the same gap by making their agents quieter, and went home.

The lever I needed was the one I reached last. A small model fine-tuned to answer and call tools without the long rambling reasoning would have gone at the 977 directly, and it was available from the first hour. I spent the final hours of the competition training it while the clock ran out, and it never made it into a submitted run.

So the lesson isn’t really about time. It’s that being right about the mechanism is not the same as acting on it — I identified the largest term in the score early, then spent two days attacking it with the wrong tools. Next time the first question is which single term dominates, and the first thing built is whatever goes at that, before anything else gets touched.