AWS Agentic Football Cup: Build AI Agents, Deploy to the Cloud, and Watch Them Play Live

Build a team of AI agents. Deploy them to production-grade infrastructure. Watch them compete on a live 3D pitch.

A deep dive into the workshop where multi-agent orchestration meets real-time competition — powered by Amazon Bedrock, AgentCore, the Strands SDK, and Kiro.

What Is the AWS Agentic Football Cup?

The AWS Agentic Football Cup is a hands-on workshop experience that puts you in the manager’s seat — except your players are AI agents you build from scratch. You’ll write real agent code, deploy it to Amazon Bedrock AgentCore, and watch your squad compete in live football matches rendered on a 3D pitch.

This isn’t a click-through demo. Every decision your agents make on the field — every pass, shot, press, and defensive positioning — comes directly from the logic you give them.

How It Works

The workshop is structured around three progressive phases:

Phase 1: Build Your Team

Write your agent code and deploy it to Amazon Bedrock AgentCore. You’ll use Kiro, an agentic IDE that accelerates every part of the workflow — from scaffolding your agent logic to debugging and iterating through natural conversation.

Phase 2: Play Matches

Set up the Player Portal, register your agents, and start competing. Benchmark your squad against three AWS-built AI opponents:

You can also go head-to-head against other participants’ teams for the ultimate test.

Phase 3: Supercharge Your Agents

Learn advanced techniques to iterate fast, improve your agents’ decision-making, and climb the leaderboard. This is where strategy meets engineering — refining how your agents reason, coordinate, and adapt in real time.

Under the Hood: The Technical Stack

What makes this workshop compelling from an engineering perspective is that it uses the same production-grade services AWS customers deploy for real agentic workloads. Here’s how the pieces fit together:

Amazon Bedrock — The Reasoning Engine

Your agents’ decision-making is powered by foundation models accessed through Amazon Bedrock. Rather than hard-coding game logic with if/else trees, your agents use LLM-based reasoning to interpret the match state (player positions, ball location, score, time remaining) and decide what action to take next.

Bedrock provides access to models from Anthropic (Claude), Meta (Llama), Amazon (Nova), and others — giving you flexibility to experiment with different reasoning capabilities, latency profiles, and cost tradeoffs. In the football context, you might find that a faster, lighter model works well for routine decisions while a more capable model handles complex tactical scenarios.

Amazon Bedrock AgentCore — Managed Agent Runtime

AgentCore is the deployment and orchestration layer. Instead of managing your own containers, scaling logic, and monitoring infrastructure, you deploy your agent code to AgentCore and it handles:

• Runtime management — Hosting your agents with automatic scaling
• Session persistence — Maintaining agent state across interactions
• Observability — Tracing agent decisions, tool calls, and reasoning chains
• Guardrails integration — Applying safety and behavioral constraints

In the football match context, AgentCore ensures your agents respond within the tight latency windows required for real-time gameplay. Each “tick” of the match simulation queries your deployed agents for decisions, and AgentCore handles the execution lifecycle.

Strands Agents SDK — Open-Source Agent Framework

Strands is an open-source Python SDK that provides the agent abstraction layer. It handles:

• Agent-to-model communication — Structured prompt construction and response parsing
• Tool integration — Defining tools your agents can invoke (e.g., querying match state, issuing commands)
• Multi-agent coordination — Patterns for agents that communicate and collaborate (think: your midfielder signaling to your striker)
• Memory and context management — Giving agents access to relevant history without overloading context windows

The SDK is intentionally minimal — it gives you the scaffolding without locking you into opinionated abstractions. You write Python, define your agent’s behavior, and Strands handles the plumbing.

Kiro — Agentic IDE

Kiro is an AI-powered IDE purpose-built for agentic development. It understands your project structure and agent architecture, so it can:

• Generate agent scaffolding from natural language descriptions
• Debug agent reasoning by inspecting decision traces
• Suggest improvements based on match performance data
• Iterate rapidly through conversational development — describe what you want your defender to do differently, and Kiro helps you implement it

This is where the development velocity comes from. Instead of manually tracing through prompt templates and tool definitions, you describe intent and Kiro translates it into working agent code.

Architecture: How a Match Works

At a high level, the match simulation follows this loop:

1. Match engine sends the current game state (positions, ball, score, clock) to each team’s agents via API
2. Your agents (running on AgentCore) receive the state, reason about it using a Bedrock foundation model, and return an action (pass, shoot, move, tackle, etc.)
3. Match engine resolves all actions simultaneously, updates the game state, and renders the next frame on the 3D pitch
4. Repeat at high frequency until the match ends

The challenge is that your agents must reason and respond within strict time budgets. If an agent takes too long to decide, the match engine uses a default action — your player effectively stands still. This mirrors real-world agentic constraints where latency and reliability directly impact outcomes.

No Experience Required

One of the standout aspects of this workshop: no AI experience or deep coding background is needed. AWS Solutions Architects and certified partners are on hand throughout to help at every step. Whether you’ve built multi-agent systems before or you’re deploying your first agent ever, you’ll walk out having built and competed with a working system.

Skills You’ll Take Home

The football metaphor is fun, but the skills are production-ready. By the end of the workshop, you’ll have hands-on experience with:

• Agent design — Building agents that reason, coordinate, and adapt in real time
• Cloud deployment — Deploying and scaling agents using production-grade AWS infrastructure
• Multi-agent architecture — Understanding the same patterns behind customer service bots, supply chain automation, autonomous workflows, and more
• Agentic development tooling — Using tools like Kiro to accelerate every part of the agent development cycle
• Prompt engineering for agents — Crafting instructions that produce reliable, repeatable agent behavior under real-time constraints
• Observability and debugging — Tracing agent reasoning chains to diagnose unexpected behavior

The Bottom Line

The AWS Agentic Football Cup takes the complexity of multi-agent systems and makes it tangible, competitive, and genuinely fun. You’re not just learning about agentic AI in the abstract — you’re building it, deploying it, and watching it perform under pressure.

When the final whistle blows, everything you’ve learned maps directly to real-world production use cases across industries. You leave with working code, cloud deployment experience, and a mental model for how multi-agent coordination actually works.

Your squad is waiting. ⚽

Key Links & Resources