Back in June, everyone in NYC was talking about the championship. Not the one at the Garden. The one happening a few blocks away at the Javits Center, where a room full of builders spent the day teaching AI agents to crawl through dungeons, dodge traps, and outscore each other for a spot on the leaderboard. That is the AWS AI League, and at the AWS Summit in New York I walked out of it in first place.
Now that the dust has settled and I have had a month or so to sit with it, I wanted to write the full story.
Here is how it is laid out. First the competition itself: what the AI League actually is, what changed this season, and how the day went. Then the two things from the Summit I have not been able to stop thinking about, the agentic launches AWS put on stage and where large language models and robotics are starting to meet, which is something I am personally deep into right now. After that, for anyone who wants the whole playbook, a full technical breakdown of how I rebuilt my agent between re:Invent and New York, plus the tips I would give anyone sitting down to their first run.
The road to New York
If you have read my 2025 re:Invent recap, you know the backstory. I came up through AWS DeepRacer, made the jump to the AI League, and entered the 2025 championship as a wildcard because I could not make it to any of the qualifying Summits. With about five minutes left before the submission deadline, one last upload pushed my username into a qualifying spot and onto the championship stage at re:Invent. I finished as the global 1st runner-up that year, second in the world.
Second is a great result. It is also the kind of result that keeps you up at night thinking about the one round that could have gone differently. So when the AI League came to the New York Summit, I showed up with a year of lessons, a rebuilt agent, and exactly one goal.
What the AWS AI League actually is
Here is the part that makes this competition so much fun to talk about. The AWS AI League is a roguelike dungeon crawler where the hero is an AI agent that you design and build.
Your agent spawns on a grid map and has to find its way to the treasure. Between the start and the goal is a maze full of stuff: walls to route around, spike traps that cost health, coins that boost your score, and locked doors that block the only path forward. Scattered across the map are challenge tiles, and every time your agent steps onto one it has to solve a live problem on the spot. Write and run code to crack a number too big for a language model to compute in its head. Scrape a website and pull out one exact fact. Recall something it was told earlier from memory. Get a guardrail challenge right, which comes down to being deliberate about exactly which words you have told it to block. Find a key, hold onto the code, and transform it correctly to open the matching door later.
Four things are scored at once: the points you earn from challenges, the lives you keep, how fast you finish, and how few tokens your agent spends getting there. The interesting part is that these pull against each other, and the real game is deciding which ones to chase.
That decision is the route. Do you send your agent after every challenge tile on the board, banking the points but spending lives on traps and burning clock along the way? Or do you pick off the high value, low risk challenges and drive hard for the treasure? There is no single right answer, and it changes map by map depending on where the keys sit, how many lives a detour costs, and how much time the clock gives you. Route strategy is the biggest lever in the whole competition and it is where I spend most of my thinking.
Token efficiency is real, but it is the last few percent. It only starts to decide anything once you are already fighting for the top few places on the board. Get the route wrong and no amount of concise output will save you.
It is genuinely a different kind of competition. You are not writing one program. You are building an autonomous system, handing it the controls, and trusting it to make good decisions in situations you did not get to see in advance.
New for this season
Three things were new this time, and all three changed how you build.
Keys and locked doors. This is a whole new paradigm for pathfinding. It stops being “find the shortest route” and becomes an ordering problem with dependencies. Your agent has to reach the right key first, hold onto the code, transform it correctly, and spend it on the matching door before that part of the map opens up at all. The highest scoring route is very often not the shortest one.
It is also worth saying plainly that agents are not good at pathfinding on their own. Hand a language model a grid with gated dependencies and ask it to plan a route, and it will give you something confident, plausible, and wrong. That is the whole reason the pathfinding tool matters so much, and why mine ended up growing into a real optimization engine rather than a prompt.
A healthcare challenge. The Risk Analyzer, worth 850 points. Your agent gets a patient’s lipid panel written the way a clinician actually writes it, a paragraph of notes with the numbers buried in prose, and has to work out which value is which, score each one against a fixed rubric, total it, classify the result, and return strict JSON. None of it is conceptually hard. It is fiddly, and fiddly is exactly where a generalist orchestrator drops a step. It has to pull eight separate fields out of sentences like “his HDL is only 33”, get every threshold and the arithmetic exactly right, and work out that “despite being on metoprolol” means the blood pressure medication box is ticked. That is a job for a narrow specialist with one instruction, not for the agent that is also trying to run the maze.
Fine-tuning folded into the agentic challenge. Model customization used to be its own separate contest. This season the small models you train plug straight into your agent as subagents, which means the architecture you pick for reliability is also the one that opens up the extra points. There is a full breakdown, and the case for skipping it, further down.
Competition day
The format had two acts. First, the workshop round, where everyone iterates on their agent and submits against the maps to climb a live leaderboard. It was led by Seyha Kry and Dana Bullukian, who created the agentic challenge. I finished that round in first place, which earned a seat in the final showdown.
One thing worth saying to anyone on the fence: the workshop is worth doing even if you have no interest in competing. You walk out of it having actually built a working agent with subagents, memory, Lambda tools and guardrails, and applied it to a real problem. The leaderboard is optional. The skills are not.
The room was full of familiar faces. A good number of former DeepRacer competitors have made the same jump across to the AI League, and sitting next to me for the workshop round was Sai Ram Naragoni, the 2021 DeepRacer world champion.
Then the showdown. The top finishers go head to head across a final set of maps that decide the championship, and the maps are not the ones you practiced on. Same rules, new questions, new layout, no second chances.
There is one more twist in the final, and it is the part I did not expect to matter as much as it did. Before each map runs you get one minute at the keyboard to write a prompt for your orchestrator. That is your only chance to tell it anything about the board it is about to walk into and to spell out the strategy you want it to follow. So you are staring at a map you have never seen, working out on the spot whether this is a run where you sweep the challenges or a run where you take the safe points and drive for the treasure, and then getting that decision into words before the clock runs out. Everything I said earlier about route strategy comes down to that minute.
The other thing about the final is that everyone starts level. The workshop scores do not carry over, so the board goes back to zero and the three of you run the same maps side by side. The agent you qualified with is the agent that runs, and that one minute of prompting is the only lever you have left.
This is where all the unglamorous work pays off, the robustness you built when nobody was watching, the edge cases you handled, the routes you tuned. My agent held up across the final three maps and came out on top.
Final standings at the New York Summit:
- rosscomp1 (me)
- JPMC-Rogue (Sai Ram Naragoni)
- yichao
All three of us walked away with $1,000 in AWS credits.
AgentCore and the agentic advances from AWS
Part of what made this Summit special is that the tools I was racing with were the same ones taking center stage on the keynote screen. A few launches stood out.
- Web Search on Amazon Bedrock AgentCore. A fully managed web search tool that lets agents ground their answers in current, cited web knowledge without data leaving your secured AWS environment. If you have ever hand-built a scraping tool for an agent, you understand exactly how useful this is.
- The optimization loop for agents in production. Recommendations, batch evaluations, and A/B tests went generally available, closing the observe, evaluate, and improve loop. Recommendations read your production traces and propose targeted prompt and tool-description changes, batch evaluation scores them against a test set, and A/B testing splits live traffic to prove the change actually holds. This is the part of agent building that usually lives in spreadsheets and guesswork, now turned into a managed workflow.
- Stronger controls as agents grow. Expanded capabilities for enforcing controls that scale as agents take on more. Anyone who has fought with an overeager guardrail will appreciate the direction.
- Kiro for iOS and Amazon Quick’s autonomous agents. Kiro went mobile in a gated preview so you can manage sessions from your phone, and Amazon Quick picked up autonomous agents for background work alongside a prioritized activity feed. A Summit that was agentic from top to bottom.
Just before the Summit, AgentCore had also picked up Payments in preview, built with Coinbase and Stripe, letting agents autonomously pay for APIs, MCP servers, paywalled content, and even other agents, with settlement running on stablecoins over Coinbase’s x402 protocol. Agents that do not just decide but transact.
Spending the morning building a competition agent on AgentCore and then watching AWS announce GA-level capabilities for the exact same primitives at the same event is a strange and great feeling. It tells you the thing you stayed up late tinkering with is the thing the industry is actually about to use.
Extra Credit: Where LLMs and robotics meet
This is the thread I am most personally excited about, so bear with me while I geek out. One of the best parts of any Summit is who you bump into on the floor.
I walked up to this particular booth because a Strands logo sitting next to a table full of robots was not something I was going to walk past. Then I spotted the little four wheeled car among them, and anyone who came up through DeepRacer will know exactly why that stopped me. I asked one of the people running the booth what it was, and they waved Cagatay Cali over to come and talk to me.
Cagatay Cali is a Research Engineer at AWS working right at the intersection of agentic AI and robotics. He is a core contributor across the Strands ecosystem, from the Agents SDK itself to Strands Robots in the experimental Strands Labs organization, and his work chases one deceptively simple idea: let a person control a physical robot with plain natural language.
If you have not run into Strands yet, here is the quick version. Strands Agents is AWS’s open-source, model-driven SDK for building agents. I have been building with it inside Aqfer to put together our own agentic systems, which is exactly why that logo on the booth pulled me over. Strands Labs is the sandbox where the team pushes the frontier, and Strands Robots is the project that takes everything I was doing in a software dungeon and points it at real hardware. It exposes more than seventy robots across eight categories, and the whole robot lifecycle, simulation, control, training, and deployment, as tools that a single Strands agent can compose. The same code drives a robot in a MuJoCo simulation and on a physical machine with one parameter change, and vision-language-action models like NVIDIA GR00T and the Hugging Face LeRobot policies turn a camera feed and a sentence into motor commands. Small models run at the edge on hardware like NVIDIA Jetson for instant reflexes, while Claude on Amazon Bedrock AgentCore handles the slower, deliberate reasoning. Fast instinct at the edge, careful thought in the cloud.
Back to that car. It was an EarthRover Mini+, the compact open-source rover from FrodoBots: a small four-wheeled robot with a camera, the kind of thing you can pick up for a few hundred dollars and drive over 4G from anywhere. In the Strands Robots code it is a first-class citizen, spun up in a couple of lines and driven with W/A/S/D velocity keys through the keyboard_rover teleoperator. Watching that little camera-equipped rover take a natural-language instruction, look at the world, and decide how to move, I could not stop thinking about DeepRacer.
The parallels are almost uncanny. DeepRacer put a 1/18 scale car with a single camera in front of thousands of builders and taught them reinforcement learning by letting them train a driving policy in simulation and then watch it run on a real track. Strands Robots does the same move for the agentic era: a small wheeled robot with a camera, a policy learned from data, simulation-to-reality transfer with one line changed, and a continuous loop of sense, decide, act, and learn. You even drive the thing with WASD to record demonstrations, the same tactile on-ramp that made DeepRacer click for so many of us. Cagatay’s stated mission, making robotics accessible to builders at any skill level, is the exact DeepRacer promise carried forward, except the track is now the entire physical world.
That is the part of this that I keep coming back to. His work bridges the gap between the traditional machine learning world a lot of us came up through, the world of training policies, tuning reward functions, and closing the sim-to-real loop, and the agentic development we are all doing today with orchestrators, tools, memory, and natural language. Those have felt like two separate tribes for a while. Strands Robots puts them in the same stack: an agent reasons in language and calls a tool, and on the other end of that tool is a learned vision-language-action policy moving real motors. The reinforcement learning heritage of DeepRacer and the agent-orchestration work I do in the AI League are not two different hobbies. They are the same story at two points in time, and watching that rover drive made the throughline obvious.
This is not abstract for me. At home, my son and I are building a Reachy Mini, the small open-source expressive robot from Hugging Face and Pollen Robotics, and here is the full-circle moment: Reachy Mini is one of the robots Strands Robots already supports. The same agentic stack I used to win a software dungeon is a stack I can point at the little robot sitting on our kitchen table. Teaching an agent to reason and then act, whether the body it controls is a maze avatar, a rover, or a desktop robot my kid gets to name, is quickly becoming the throughline of everything I am into. Getting to build that with him, and to see the professional version of the same idea running on a booth floor at the Summit, is the kind of week that reminds you why you got into this.
If any of that got you curious, here is where to start. strandsagents.com is the home of the SDK, Strands Labs is the experimental organization on GitHub, and Strands Robots is the project itself, for controlling real hardware with natural language. Cagatay also maintains awesome-strands-agents, a curated list of everything happening in the ecosystem.
What I changed since re:Invent: the lessons and the enhancements
I left re:Invent in second place with a notebook full of things I would do differently. The New York agent was a rebuild around those lessons. Here is what actually changed, and why.
The architecture that won was an orchestrator agent on Amazon Bedrock AgentCore, supported by a small set of specialist subagents and tools. A few hard-won principles drove the whole design.
The model changed, so the strategy had to change. This is the single biggest lesson from re:Invent to New York, and it is worth explaining carefully. At the Vegas championship my orchestrator ran on Sonnet 4. A model that strong could hold every tool, every rule, and every challenge type in one prompt without losing the thread, so the winning move back then was actually to pile everything onto the orchestrator and skip delegation entirely. Fewer subagent hops meant less time spent, and time is scored. At the New York Summit the orchestrator ran on Haiku 4.5. Haiku 4.5 is a genuinely capable and much faster model, but when I stacked every tool and every instruction onto it the way I had with Sonnet, the sheer volume of information competing for attention would occasionally make it slip. It would send a tool the wrong starting position, or invent a parameter nobody asked for. The lesson was clear: on a smaller, faster orchestrator, delegation is not a nice optimization you trade away for speed. It is a requirement.
Give the orchestrator less to think about. So I split the work. The orchestrator handles the quick challenges and routes the hard, detail-sensitive ones to focused subagents that do one job well. A pathfinding specialist owns the route. A separate specialist owns the Risk Analyzer. Each one has a narrow prompt and does not context-switch, so it does not drop a step. As a bonus, in a competition that scores your token usage, moving the heavy, verbose work into subagents keeps the orchestrator’s own output lean.
Build real tools, not prompts pretending to be tools. The code challenge needs an actual code interpreter. The web challenge needs an actual fetcher. I wired these up as Lambda tools attached through AgentCore so the agent could call them natively. The pathfinding tool in particular grew into a real optimization engine, because finding the highest-scoring legal route through a maze with locked doors and health constraints is a genuinely hard search problem.
Guardrails protect you and can also block you. The thing worth real attention is the specific list of words you configure it to block. Get that list wrong in either direction and it costs you points you should have won. Scoping the guardrail to where it belongs was one of the highest-leverage things I did.
Fine-tuning your own models is now part of the game
This is the change I flagged earlier, and it is worth the detail. Because model customization is now folded into the agentic challenge rather than run as its own separate contest, the subagents I was already using for reliability can double as a scoring lever.
Here is how it works. Inside the AI League you can fine-tune small open models (the workshop starts you on Qwen 3 0.6B) to do one narrow job: take a challenge’s input and emit the exact tool call for it. You are not teaching the model to solve the whole problem, you are teaching it to call the right tool with the right parameters, and the platform handles executing that tool and routing the result back. Training runs on Amazon SageMaker using reinforcement learning from verifiable rewards, in two stages: first the model learns to produce the tool-call format, then it learns to relay the tool’s output faithfully so an 80 move path or an exact JSON answer comes back without a single dropped token. Deployment is a couple of clicks, and each trained model gets assigned to one of your subagents.
Whether you take this on is a genuine strategic decision, not a given. There are extra points in it, and if you are chasing every last one then the delegation architecture you already built for reliability is sitting right there as a ready-made home for them, because every subagent is a slot for a cheap, fast specialist.
The catch is the clock. A workshop round is only two or three hours, and that is the whole constraint. Every minute you spend training and deploying a model is a minute you are not spending on your routing strategy, your tools, or your guardrail, and those are the things that decide most runs. If this is your first time out, get the agent working properly first. Come back for the fine-tuning points once the rest is solid, or when you already know you are in a fight for the top of the board.
I am keeping the deeper specifics at the level of architecture and philosophy on purpose. The exact prompts, reward functions, and tuning change every season, and half the fun is figuring them out yourself.
One thing worth knowing before you go in: the rules and the points are not fixed. They shift from Summit to Summit, and they can change again at re:Invent. Treat any scoring detail you read anywhere, this post included, as a snapshot rather than a rulebook, and read the scoring for the event you are actually sitting in.
Tips if you want to get started
You do not need to have done DeepRacer or competed before. Here is what I would tell anyone sitting down to their first run.
- Read the scoring before you write a line. Points, lives, speed, and tokens all count, and they trade against each other. Everything else follows from knowing which lever matters most on the map in front of you.
- Then settle your route strategy, and treat it as the big one. Every challenge you chase costs time and risks lives. Work out which ones are worth the detour on a given map and which ones you walk past on your way to the treasure. This is the decision that wins and loses runs.
- Start from the community edition. There is a public repo (linked below) that deploys the whole thing into your own AWS account as a stack. Being able to practice on your own infrastructure, as often as you like, without burning Summit time is a massive advantage.
- Split hard jobs into specialists. One agent trying to be good at everything is how you drop steps under pressure. Small, focused subagents are more reliable.
- Test your tools in isolation, then work out what actually broke. When something goes wrong mid-run it can be any of three things: the tool itself failing, the model not being strong enough for what you are asking of it, or your orchestrator instructions telling it the wrong thing. Verifying each tool end to end on its own is what lets you rule the first one out quickly, so you are not rewriting a prompt to fix a broken tool, or debugging a tool when the real answer is a better model.
- Pay attention to the specific words your guardrail blocks. That list deserves more thought than most people give it.
- Worry about tokens last. Strip preamble and answer with the value rather than a paragraph about the value, but do it once the routing and the tools are solid. Token efficiency separates the top few places, it will not rescue a bad route.
Your turn: the virtual league is next
Here is the best part for anyone reading this and feeling the itch. You do not have to be at a Summit to play. The AWS AI League virtual league kicks off soon, run online through AWS Builder Center, and it is another live shot at the exact same prize: the top builders advance to the Grand Finale at re:Invent in Las Vegas to compete for the $50,000 prize pool. Same game, same stakes, no plane ticket required to get started.
If you have ever thought about trying one of these competitions, this is the run to jump into. Build an agent, climb the leaderboard, and you could be booking a trip to Vegas. I will be grinding toward re:Invent from the finalist side, and I would love to see a crowd from this community show up in the brackets.
Resources to get you in the game
Everything you need to start is public and free to try.
- AWS AI & ML Community on Discord. The fastest way in. This is where the community shares strategies, asks questions, and announces events like the virtual league. Join here.
- The AI League community edition repo. The open-source version, deployable as a stack so you can practice against the real thing before you ever hit a live leaderboard. github.com/aws-ai-community/ai-league-community-edition
- The official 2026 championship announcement. The rules, the format, and how the season is structured. Read the announcement.
- The AWS AI League page. Official overview, rules, prize pool, and how to join a Summit or the virtual league. aws.amazon.com/ai/aileague
- The AWS AI League community space on Builder Center. Where the community’s writeups, tips, and event news live. Visit the space.
- My 2025 re:Invent recap. The first chapter of this story, from wildcard to the world stage. Read it here.
- Come and say hello. I am on LinkedIn, and I write most of this up on AWS Builder Center. Always happy to talk agents, DeepRacer, or robots.
What is next
Winning the Summit earned an all-expenses-paid trip to AWS re:Invent to compete on the championship stage for a share of the prize pool. Last year I left re:Invent as the runner-up. This year I get to go back and try to finish the job.
Huge thanks to my team at Aqfer for the support, to AWS and the organizers who pour so much into running these events, and to the fellow finalists who made the final round a real fight. The road to re:Invent starts now.
If you have been curious about agentic AI and you want a fun, competitive, hands-on way to actually learn it, come build an agent and join us. I will see you in the dungeon.
It was a good summer to be a builder in New York. Now back to work.