How I won the AWS AI League in Hong Kong

I showed up to the AWS AI League Agentic Challenge at AWS Summit Hong Kong on 17 June 2026 without having read a single page of the workshop docs. Then the venue Wi-Fi at the Convention and Exhibition Centre died before I'd even logged in, and the three-hour clock started anyway.

I still won. The trophy photos are on the award page, so this post is about the part that's actually useful: what you can get done in three hours on a USB tether, with a small model that ignores half of what you tell it.

A trophy, a belt, and a ticket to Las Vegas.

Copy linkThe game

The AI League is AWS's competitive AI programme, and the format is a timed, gamified dungeon. Your agent walks a grid, hits challenge tiles, and gets scored on whether it solves them, how many lives it keeps, and how many tokens it burns along the way.

There's a Model Customization track too, but I entered the Agentic AI Challenge: build an autonomous agent with Amazon Bedrock AgentCore and drop it into the maze. More than 200 people filled the Arena, including enterprise teams from Cathay, Manulife, Octopus, Crypto.com, and Lalamove, all working against the same three-hour window.

Qualifying runs as a workshop with a live leaderboard. You can keep tweaking tools, memory, guardrails, and the supervisor prompt, and resubmit as often as you like. The on-stage finale is a different game entirely: your code is frozen, the supervisor can't be edited, and the only lever you have left is a short steering prompt before each map.

I qualified second with 8063 points across 13 submissions, then won the finale after the board reset.

Copy linkStarting from a hotspot

The AWS Builder platform straight-up refused to load on the venue network, so the whole room switched to mobile hotspots. The Arena filled with clashing signals, which ruled out tethering over Wi-Fi. I had to plug my phone into the laptop with a USB-C cable instead, and lost at least the first ten minutes just getting online. Not a great start when the whole window is under three hours.

I built in this order: pathfinder, tools, supervisor prompt, memory, guardrails, sub-agents. The starter pathfinder from the workshop was already good enough, so I left it alone. Pathfinding wasn't where the scarce minutes should go. The Lambdas didn't need much iteration either. I wrote them in Cursor on the clock, checked that they scored then moved on. What actually moved the leaderboard was watching what the agent did and deciding what to fix next, not writing prettier Python.

Copy linkWhat I built

The architecture was a supervisor on Bedrock AgentCore routing each encounter to a tool or a specialist. I didn't go for the fine-tuning track. The agent model is Amazon Nova 2 Lite for everyone, and you don't get to swap it out, so all the real work is in what you build around it. The full list:

• The starter pathfinder was left untouched
• One Lambda for maths and code execution, because the model will happily invent arithmetic if you let it
• One specialist sub-agent, WebResearcher, for anything that needed a live page
• AgentCore Memory
• Amazon Bedrock Guardrail

I considered adding more Lambdas but eventually didn't add any extra ones. Every extra agent is more surface area to debug.

Three things did most of the scoring. (The exact supervisor prompt stays private until after re:Invent, sorry.)

Spell out the behaviour. Explicit do / don't / must rules, because the environment isn't a chat. Every clarifying question costs a life, so the agent has to act without asking a human.

Don't ask Nova to do a function's job. A large Fibonacci term under a modulus, code execution, and a fact on a live URL all go to the Lambda or to WebResearcher. The model is the router, not the calculator.

If it's a guardrail challenge, configure a guardrail. I set denied topics and filters on the Bedrock Guardrail itself, which is a different mechanism from a polite refusal in the supervisor. The challenge types that paid here were guardrail, maths, code, and web fetch.

Token economy matters, but it's the second lever, not the first. Getting the challenge right earns the bulk of the points; shortening the answers comes after that.

Copy linkDebugging from the combat log

The game shows you, on screen, which tile the agent hit, what it answered, whether it was correct, and whether it scored. That log turned out to be far more useful than trying to guess from the leaderboard.

I don't remember the exact diffs on the last few runs, but I do remember that my second-last submission scored higher than my last one, which is a good reminder that more changes aren't automatically more points. With eleven minutes left I still wasn't on the first page of the leaderboard. I kept submitting, and qualifying closed with me in second.

Qualifying: second place, 13 submissions, into the on-stage finale.

Copy linkWhat still fails

Memory was the weak point. Some tiles ask how many of a given challenge type were on the board when the map loaded, and the answer is literally sitting in the map context the agent receives. Nova 2 Lite would sometimes ignore it and guess anyway. Hit and miss, and it's the piece I want fixed before Las Vegas.

The model is also "naughty" in a more general way: it skips parts of a long supervisor prompt, so a rule you wrote can simply never fire. That's a small-model attention problem, not a mystery. Since everyone is stuck with Nova 2 Lite, there's no fixing it by upgrading the model. For re:Invent I need to work out how to structure the instructions so they actually get followed, instead of dumping the whole set into one blob the model can ignore.

Copy linkThe finale

On stage you can't touch the Lambdas, the guardrail, the memory config, or the supervisor. All you get is a steering prompt: a short instruction for this map, this timer, this layout. It's a decent test of whether you built a system or a script for one map, because the maps are new and everyone's qualifying score is wiped.

Having spent the workshop keeping the tools boring and the topology small paid off here. The steering prompt could be a strategy note instead of an attempted rewrite of the agent.

The more immediate problem was that I walked on stage with the laptop at 10% and no power bank. Most people had already turned their hotspots off, so the laptop could finally reach the phone over Wi-Fi. I spent the finale hoping both of them would outlast the maps. Luckily, they did. Round 3 finished at 5760, just ahead of Sam Lam and Shawn Zeng, in the first Hong Kong edition of the tournament.

Copy linkWhat I'd repeat

Don't overbuild in three hours. The starter pathfinder plus one execution Lambda plus one research sub-agent covered every challenge type that actually paid, and fine-tuning was a bonus track I happily skipped.

And don't treat the model as the system. Nova 2 Lite is fast and cheap and it drops instructions, so deterministic work goes in tools, refusals go in a real guardrail, memory holds the state the prompt can't be trusted with, and the combat log gets watched like production.

The bigger lesson is the one I keep running into at work: generating the next token isn't the bottleneck. Judging the failure, choosing the next change, and taking responsibility for the submit is the actual job. I wrote more about that in When writing code stops being the bottleneck. The League was the same idea compressed into an afternoon.

If you're competing later this year, the community write-ups are worth reading, especially the London hints and the NYC walkthrough. This was the Hong Kong version: no prep, a hotspot, the same Nova 2 Lite as everyone else, and a lot of staring at the log. The rest of the photos and press are on the award page. I'm on LinkedIn if you want the re:Invent prep. See you all in Las Vegas :)