🏆 Agents League: Celebrating the Builders Who Made Agents Battle for Glory

The arena has closed, the scores are in, and the champions are crowned. Agents League, the esports-inspired hackathon at the heart of AI Skills Fest 2026, brought together tens of thousands of developers to build, ship, and compete with agentic AI. This is the celebration post: a spotlight on the winners across every category, the numbers behind the movement, and the engineering lessons worth carrying into your next build. 

If you competed, watched a Reactor battle, or completed a skilling playlist, this recap is for you. You didn't just attend an event. You helped set a record. 

Before we get to the winners, there is a useful playbook hiding in their submissions. Later in this post, the section “What the Winners Teach Us: Patterns Worth Stealing” breaks down the build patterns future attendees should pay attention to: multi-agent orchestration, meeting users where they already work, testing discipline, and accessibility-first design. If you are planning to enter next time, read the winners not just as inspiration, but as a practical checklist for what great agent projects have in common. 

  

🥇 Best Overall: $15,000 Grand Prize 

Afterlogin: The Hunt — https://github.com/jlynch160/afterlogin-the-hunt  (Creative Apps track) 

The top weighted score of the entire field. Afterlogin: The Hunt is described by its builders as "one engine, two faces": a cinematic Security Operations Centre (SOC) night on one side, and a coached training game on the other. The same underlying engine powers both an atmospheric narrative experience and a hands-on learning simulation. 

Why it won: it fused genuinely creative design with a real-world use case (security operations training) and executed both at a high polish level. Built with GitHub Copilot for AI-assisted development, it's a masterclass in using one well-architected engine to serve two very different user experiences. 

🏅 Category Champions 

Best Creative App: StudyMate, "Study with Matey" — https://github.com/adetorojeremiahfadesayo/StudyMate  

Tech: GitHub Copilot 

 

StudyMate turns a student's own notes into a gamified, story-driven revision session, complete with XP and progression. Instead of generic flashcards, it grounds the experience in the learner's real material and wraps it in a narrative loop that keeps motivation high. It is a great example of pairing personalisation with game mechanics to solve a persistent problem: staying engaged while revising. 

Best Reasoning Agent: DELPHAI — https://github.com/jlynch160/delphai  

Tech: Microsoft Foundry 

DELPHAI is an 11-agent reasoning council that checks the maths, explains the risk, and refines its own answer before responding. Rather than a single model producing a one-shot response, DELPHAI orchestrates a panel of specialised agents that debate, verify, and converge, a pattern that directly addresses the reliability gap in high-stakes reasoning. It's a textbook demonstration of multi-agent orchestration on Microsoft Foundry. 

Best Enterprise Agent: Archon — https://github.com/upgradedev/archon_azure  

Tech: Microsoft 365 Copilot 

Archon is a 7-agent financial-intelligence pipeline for small and medium businesses, delivered right inside Microsoft Teams. It meets users where they already work, chaining specialised agents to turn raw financial data into actionable intelligence. Archon shows how enterprise-ready agents built for Microsoft 365 Copilot can deliver serious business value without forcing users to leave their daily workflow. 

🌟 Special Awards 

Across 8 categories, 14 winners shared a $55,000 prize pool. Congratulations to every one of them, and to the thousands of builders who submitted. 

🧠 What the Winners Teach Us: Patterns Worth Stealing 

Look across the champions and clear engineering patterns emerge. These are the takeaways AI engineers and developers should carry into their own projects.

1. Multi-agent orchestration beats the monolithic prompt

The two reasoning-heavy winners, DELPHAI (11 agents) and Archon (7 agents), both won by decomposing a hard problem into specialised, cooperating agents. A "council" or "pipeline" of narrow agents that verify each other outperforms a single model asked to do everything at once. 

Here's the shape of that pattern, illustrated conceptually with the Microsoft Agent Framework style used with Microsoft Foundry. (This is an illustrative pattern, not the winners' actual code.) 

# Illustrative multi-agent "reasoning council" pattern
# Conceptual sketch, not the winning team's source code.

async def reasoning_council(question: str) -> str:
    # 1. Specialised agents each own one responsibility
    solver = create_agent(
        role="Propose an answer with its reasoning"
    )

    math_check = create_agent(
        role="Verify every calculation, flag errors"
    )

    risk_agent = create_agent(
        role="Explain the risks and assumptions"
    )

    # 2. Draft, then critique
    draft = await solver.run(question)
    math = await math_check.run(draft)
    risk = await risk_agent.run(draft)

    # 3. Refine using the critiques before answering the user
    refined = await solver.run(
        f"Question: {question}\n"
        f"Draft: {draft}\n"
        f"Math review: {math}\n"
        f"Risk review: {risk}\n"
        "Produce a corrected, final answer."
    )

    return refined

The lesson: reliability comes from structure. Give each agent one job, let them check each other, and refine before you respond. That is exactly how DELPHAI "checks the math, explains the risk, and refines its answer."  

2. Meet users where they already are

Archon delivers financial intelligence inside Microsoft Teams. StudyMate builds on a student's own notes. Winning agents reduce friction by integrating into existing workflows rather than asking users to adopt a new destination. When you build enterprise agents, target the surface, such as Microsoft 365 Copilot, Teams, and Copilot Studio, where the work already happens.

3. Test rigouris a differentiator, not an afterthought 

Athenaeum won Top Student with 611 tests behind its multi-agent learning system. In a field of prototypes, evidence of engineering discipline stood out to judges. Agentic systems are non-deterministic, so a strong evaluation and test harness is what turns a demo into something trustworthy.

4. Design for everyone from day one

CLARO (accessibility-first reasoning) and Tell My Day (assistive storytelling for non-verbal users) prove that responsible, inclusive AI isn't a constraint; it's a source of the most meaningful innovation. Accessibility completions were a top skilling path this year, and the winners reflected it. 

🎮 The Three Tracks and Their Toolchains 

Agents League ran three build tracks, each anchored to a Microsoft developer platform. The winners map directly onto them: 

• Creative Apps → GitHub Copilot. AI-assisted development from concept to code. Winners: Afterlogin: The Hunt, StudyMate. (35% of the field.) 

• Reasoning Agents → Microsoft Foundry. Multi-step reasoning and agent orchestration. Winner: DELPHAI. (46% of the field, the most popular track.) 

• Enterprise Agents → Microsoft 365 Copilot & Copilot Studio. Business-ready knowledge agents. Winner: Archon. (19% of the field.) 

🔴 The Reactor Battles: Learning in Public 

The live Microsoft Reactor build battles were where the thousands of developers learned together in real time. The community connected over four live  broadcasts.  Microsoft Reactor Agents League series

A standout moment: Kyle Daigle, CMO of Microsoft Developer and COO of GitHub, live-coded his own project on stream during the Creative Apps Reactor Battle, an authentic build-along that resonated with the developer audience. As one attendee put it: "These types of sessions are the best, where we can see code and flows. It's like we learn more by visualising." 

📚 Skill Up Like a Champion: The Developer Playlists 

Winners don't appear from nowhere; many skilled up first. Seven role-based developer paths on AI Skills Navigator drove thousands of completions, spanning GitHub Copilot, Microsoft Foundry, and Microsoft 365. The top five learning playlists: 

• Develop your first agent with Microsoft Foundry, completions (the runaway favourite) 

• Learn AI-assisted coding with GitHub Copilot 

• Accessibility in practice  

• Optimise agentic DevOps with Azure DevOps & GitHub Copilot 

• Build and orchestrate agents with Microsoft Foundry 

Completion earned free GitHub & Microsoft certification vouchers and Credly badges. If you want to be on next year's winners list, this is where to start. 

🔧 One Honest Lesson for Next Time 

Transparency matters, so here's a builder-to-builder tip drawn from the judging data. Of the final submissions, the single biggest disqualifier was a missing demo video, followed by no listed repository. Brilliant projects were screened out on a technicality. 

The takeaway for future hackathons: treat your demo video and public repository as first-class deliverables, not last-minute additions. A working agent nobody can see or reproduce can't win. Record the demo early, keep the repo public, and document how to run it. 

✅ Key Takeaways 

• Multi-agent architectures dominated the podium: DELPHAI's 11-agent council and Archon's 7-agent pipeline show that decomposition and self-verification win. 

• Integration and inclusivity are differentiators: winners met users inside Teams, in their own notes, and designed for accessibility from day one. 

• Engineering rigour gets noticed: 611 tests helped Athenaeum win one of  the Top Student awards. 

• Submission hygiene is non-negotiable: a demo video and public repo are the price of admission to judging. 

🚀 Your Next Move 

Whether you're a returning competitor or inspired to enter your first battle, here's how to keep building: 

• 🎬 Rewatch the battles: Microsoft Reactor Agents League series
• 📘 Start skilling: AI Skills Navigator AISF 2026 developer playlists
• 🤖 Build reasoning agents: explore Microsoft Foundry
• 💡 Ship with AI assistance: GitHub Copilot
• 🏢 Build enterprise agents: Microsoft Copilot Studio

To every builder who entered the arena, streamed a battle, or completed a playlist: thank you. You didn't just compete; you showed the world what's possible when developers and agentic AI build together. The champions above earned their moment, but the real story is a global community of 31,000 developers levelling up at once. 

The arena will open again. When it does, will your agent be on the podium? 🏆 

Agents League was part of AI Skills Fest 2026 and was open to the public at no cost. Figures reflect the completed submission and judging period after excluding Microsoft-affiliated participants. Winner descriptions are drawn from the official Agents League Hackathon summary.