AWS Summit Bengaluru 2026:
How I Won the AWS AI League Championship
By Mayur Dhavan - AI Automation & Development Engineer
First place in the AWS AI League, the Championship Belt, and a fully sponsored trip to AWS re:Invent 2026 in Las Vegas. It was the kind of finish that makes every late-night iteration, every failed run, and every prompt revision suddenly feel worth it.
Introduction
Bengaluru was electric that day. AWS Summit Bengaluru 2026 was already packed with builders, demos, and the usual rush of big product announcements, but the AWS AI League had its own gravity. This was not a polished slide-deck competition. It was an arena for autonomous agents, and the prize was serious: the championship belt, the title, and a fully sponsored trip to AWS re:Invent 2026 in Las Vegas.
I came in knowing the only thing that mattered was execution. The agent had to think, navigate, solve, and adapt on its own. It had to survive bad map geometry, misleading interactions, hard-coded constraints, and the brutal economics of token usage. When you build agentic systems long enough, you learn that raw intelligence is not enough. Reliability wins. Determinism wins. Clear tool contracts win.
The Challenge
The game environment was a dungeon designed to punish shallow agents. To score, the agent had to move through dynamic maps, collect value, avoid traps, and complete coding or mathematical challenges along the way. Spikes could burn score. Locked doors could waste turns. A naive shortest-path strategy would look clever right up until it walked straight into a penalty tile or spent too many steps chasing low-value loot.
The deeper constraint was token efficiency. Every detour in reasoning, every unnecessary tool call, and every bloated chain of thoughts had a real cost. This was not just an AI challenge; it was a systems design challenge. The best agent was the one that could convert context into action with minimal waste. That forced me to think about the entire stack as one coherent control surface rather than a collection of disconnected tools.
The Architecture
My stack was built around Amazon Bedrock AgentCore, Amazon SageMaker Code Editor, AWS Lambda, and Python. Bedrock AgentCore handled orchestration and tool usage, but the key insight was that the model should not be trusted to improvise on tasks that needed deterministic behavior. Wherever the dungeon rewarded precision, I pushed logic into purpose-built tools.
1. Pathfinding Lambda
I wrote a custom Python Lambda dedicated to navigation. It did not just search for a path; it actively avoided spikes, accounted for locked doors, and selected routes that were operationally safe. That gave the agent a reliable movement primitive instead of forcing the model to reason from raw map state every time.
2. Standard-Library Lambdas
I built a WebScraper and a CodeExecutor as standard-library Python Lambdas. The CodeExecutor was timeout-enforced by design because any uncontrolled execution path could become a liability under competition pressure. These tools gave the agent a clean way to fetch, evaluate, and verify without blowing up latency or reliability.
3. Guardrails and Prompt Discipline
Bedrock Guardrails were there for a very practical reason: the dungeon included conversational traps designed to derail the agent. I paired guardrails with strict system prompts so the agent stayed in its operational lane, ignored bait, and kept translating game state into the next best action.
4. Fast Iteration Loop
Amazon SageMaker Code Editor became the control tower for rapid iteration. I could tighten prompts, adjust Lambda behavior, and test agent responses quickly enough to keep up with the competition clock. That loop matters because in an agent competition, the winning architecture is usually the one that can absorb new failure modes fastest.
The unglamorous truth is that this architecture won because it reduced ambiguity. The model focused on planning and tool selection. Lambda functions handled deterministic execution. Guardrails reduced drift. Prompting compressed strategy into a form the agent could apply repeatedly under stress. That is what good agent engineering looks like in practice.
The Finale
The most dramatic part of the day came before the final even started: I barely made it into the Top 3. That kind of qualification can either rattle you or focus you. Then came the twist. The live finale reset everyone to zero for a three-round gauntlet with dynamic maps. No backend code edits were allowed. No rescue deployment. No last-minute Lambda patch. Only live prompting.
Master Prompt
use strategy smart_lootThat prompt was not magic. It worked because the architecture behind it was already disciplined. The strategy encoded the agent's priorities under uncertainty: maximize meaningful loot, keep movement safe, stay alert to puzzle opportunities, and do not waste tokens on decorative reasoning. In Round 1, the agent executed almost exactly the way I had hoped when I designed the system. It took first place immediately. More importantly, it stayed stable while the environment kept changing.
That is what I will remember most about the win. Not a flashy single move, but the feeling of watching a system hold its shape under pressure. Three rounds. Dynamic maps. Live audience. Zero backend changes. Just prompting, preparation, and an agent that did exactly what it was built to do.
Conclusion
Winning the AWS AI League at AWS Summit Bengaluru 2026 was a milestone, but it also clarified something bigger for me. The future of agentic AI belongs to builders who can combine strong model orchestration with deterministic tooling, safety controls, and clear operational prompts. The gap between a demo and a dependable autonomous system is still mostly engineering.
Next stop: Las Vegas for AWS re:Invent 2026. I am taking the same mindset with me - build systems that can reason, act, and recover in the real world. Bengaluru gave me the belt. Las Vegas is where I want to keep pushing the ceiling on what autonomous AI agents can actually do.
The Road to Las Vegas: The $50,000 Global Finale
Winning in Bengaluru was not the finish line. It was the qualifier. The championship run officially earned me a place in the AWS AI League Global Finale at AWS re:Invent 2026 in Las Vegas, where the field narrows to just 25 participants from around the world. That changes the meaning of every decision. At this level, you are not competing against prototypes or nice demos. You are competing against builders who have already won their way through serious technical pressure, which means the margin for error gets brutally small. Tool reliability, route quality, prompt discipline, and token efficiency all stop being advantages and start becoming the minimum entry fee.
That is exactly why this next stage is exciting. In Las Vegas, I will be facing the best 24 developers from across the globe for a massive $50,000 prize pool, and I am treating that like the ultimate stress test for everything I built in Bengaluru. The preparation now is deeper, sharper, and more deliberate: stronger prompting, tighter execution paths, cleaner recovery behavior, and a system that can stay composed when the format gets chaotic. I am going into the global finale with confidence, but also with full respect for the room. Bengaluru proved the architecture could win. Las Vegas is where I want to prove it can do it against the world.