Agentic AI: How Atos upskilled 400 engineers in a three-day AWS AI League sprint

From theory to delivery: How Atos upskilled 400 engineers in agentic AI

400 engineers. A three‑day sprint. A dungeon maze, traps, treasures and a live leaderboard. According to Atos and AWS, that’s how they moved large cohorts from conceptual familiarity with agentic AI toward hands‑on delivery capability during a 2026 AWS AI League event.

What “agentic AI” means here

Agentic AI refers to systems made of one or more autonomous agents that call tools, keep state and make decisions to reach goals. The league pushed participants to design architectures that combined model reasoning, tool integrations, memory and safety controls while working under strict resource and time limits.

Why a competition rather than a lecture

Organizers picked a gamified, competitive format to speed decision‑making and make trade‑offs visible. The leaderboard and scoring made latency, token use, guardrail behavior and orchestration complexity concrete and measurable. Organizers said this produced faster skill adoption than passive training alone.

The three‑day blueprint

• Event year: 2026.
• Scale: 400 Atos engineers participated.
• Format: three days, with a 2‑hour kickoff workshop, daily 1‑hour office hours, and a 1‑hour finale for the top three teams.
• Participant baseline (organizers’ breakdown): 5% no prior knowledge, 25% basic awareness, 50% understood the topic but had no hands‑on experience, 20% had practical experience with agentic AI services.

The challenge, a dungeon maze that maps to production patterns

Teams built autonomous agent systems to navigate a dungeon: pathfind through a maze, solve tile puzzles, avoid traps, collect coins and reach a treasure within a limited set of lives and a time budget. Correct solutions earned points and incorrect actions reduced a finite “lives” counter. Coin collection and map exploration offered low‑risk score opportunities. Concise, token‑efficient responses were rewarded, and teams earned bonus points for producing specialist small models via fine‑tuning.

Tooling and architecture (what participants used)

Organizers ran the league on AWS infrastructure and described a toolkit that emphasized production‑relevant patterns rather than toy stacks. The components named in event materials include:

• Amazon Bedrock as the foundation‑model layer
• Amazon Bedrock AgentCore (runtime, AgentCore Gateway, memory, Code Interpreter)
• Amazon Bedrock Guardrails for content and safety controls
• AWS Lambda for custom tools (pathfinding, code execution, scraping)
• Amazon SageMaker and SageMaker Studio for development and serverless fine‑tuning workflows (organizers referenced an RL‑style fine‑tuning approach described as “RLVR”, RL‑style fine‑tuning)
• AWS Workshop Studio to host the league experience
• Third‑party developer tooling (Kiro was used by some teams)

Event materials said AgentCore Gateway routed agent tool calls to Lambda (using what organizers called the Model Context Protocol, MCP), AgentCore memory persisted context like collected keys and solved tiles across interactions, and the Code Interpreter executed code securely for computational tiles. For pathfinding, teams implemented algorithms such as breadth‑first search (BFS) in Lambda functions to balance latency and cost under a token budget.

How scoring taught the right incentives

The leaderboard balanced correctness, robustness and resource economy. Categories included:

• Correctness: solving puzzles and answering questions earned points.
• Risk management: incorrect answers cost lives and could eliminate a run.
• Exploration and optional tasks: coin collection and map completion produced low‑risk points.
• Efficiency: concise, token‑efficient agent outputs scored higher.
• Model work: fine‑tuning specialist small models earned bonus points, encouraging teams to learn model customization.

Organizers emphasized that these incentives nudged teams away from a “let the model do everything” approach and toward pragmatic designs that offloaded repeatable, deterministic tasks to Lambda tools and cached common results in memory to reduce token consumption.

“Academic learning gives you the foundation, but the AWS AI League puts it under pressure in a way that genuinely changes how you think. Building a production-style multi-agent architecture on real AWS infrastructure, not a toy project, but something scored on both performance and efficiency, forces you to internalize concepts rather than just understand them. You can’t look up the answer when the clock is running. That time pressure, combined with the fact that your decisions have real consequences on the leaderboard, creates a depth of engagement that’s hard to replicate in any other learning environment. It bridges the gap between knowing and doing in a way that sticks.”

“Taking the step from theoretical knowledge to hands-on experience can be daunting on the one hand, and challenging knowing where and how to start on the other. Atos has successfully used the AWS leagues for Reinforcement learning with AWS DeepRacer, model fine-tuning with AI League, and now Agentic AI in this year’s league, to give our teams the forum in which to gain experience and develop their skills in an engaging and fun environment, without the pressure to perform in a real-world project. The level of participation across the company and the results achieved by Atos entrants in the public leagues speaks to the effectiveness of this approach to learning.”

Measured outcomes (what organizers reported)

• 400 engineers completed the three‑day league and built working multi‑agent demos on AWS infrastructure.
• Participants gained practical skills across Amazon Bedrock, Bedrock AgentCore, Bedrock Guardrails, AWS Lambda and Amazon SageMaker; several internal champions were identified.
• Competition accelerated cross‑team collaboration and pattern sharing, particularly around observability, guardrail tuning and cost control.
• Top three finalists were James Ponter (winner), Adam Różewicki and Eduard‑Cosmin Socol.
• AWS AI League formats are offered for enterprise events throughout 2026 and at select AWS Summits and virtual events, per event materials.

Practical lessons that translate to production

• Prompt engineering under constraints: Time and token budgets force concise, deterministic prompts and fewer tool calls. Tip: design prompts to ask the model only for what it cannot compute locally, and cache deterministic outputs in memory.
• Architecture trade‑offs: More agents can make each component simpler but increase orchestration overhead and latency. Tip: measure end‑to‑end latency and move CPU‑heavy deterministic work into Lambda tools.
• Guardrails require careful tuning: Safety controls block risky outputs but can produce false positives that break flows. Tip: stage guardrail policies and test them with canary datasets before full enforcement.
• Observability is essential: Structured logs, trace IDs and sampled traces helped teams debug why agent chains failed. Tip: standardize telemetry formats and correlate model calls with tool invocations and memory state.
• Fine‑tuning helps selectively: Specialist, small models earned leaderboard bonuses, but fine‑tuning needs disciplined datasets and clear evaluation. Tip: keep datasets small and focused; treat fine‑tuning as a targeted optimization, not a catchall fix.
• Identity and audit choices matter: AWS guidance highlights that some gateway auth modes can log JWT claims in CloudTrail, avoid placing PII in those fields and apply least‑privilege IAM. See guidance on how to set up inbound authorization for your gateway.

Operational checklist for running an AI League-style sprint

• Define constraints that force trade‑off thinking: token budgets, limited lives, and run time limits.
• Choose a repeatable scenario that maps to production patterns: tool calls, memory use, multi‑agent orchestration and observability.
• Provision observability upfront: CloudWatch (or your preferred telemetry), structured logs, trace IDs and a debug playbook.
• Decide identity/auth strategy early: prefer ephemeral identifiers over PII in JWTs; scope IAM to gateway ARNs; consider offloading auth to a policy Lambda if compliance requires it.
• Prepare a fine‑tuning workflow and guard dataset access, small, validated datasets work best for targeted specialist models.
• Facilitate properly: a kickoff, daily office hours and a finale keep momentum, normalize help channels and make judging rubrics transparent.
• Plan follow‑up: convert top demos into 3-6 month pilot projects with production hardening, governance and cost estimates.

Open questions organizers didn’t fully address

The league is an effective way to bootstrap capability quickly, but several operational and measurement questions remain:

• Long‑term retention and impact: How many teams converted demos into production pilots, and what was the adoption rate over months? Organizers reported champions emerged, but longitudinal metrics were not published.
• Production governance and sovereignty: Atos references “Sovereign Agentic AI Studios” in its strategy; event materials did not disclose detailed compliance or data‑sovereignty configurations for production agentic systems.
• Costs: The event stressed token and compute efficiency, but organizers did not publish dollar cost per participant or per demo, trackable metrics every leader should collect for pilots.
• Scoring transparency and reproducibility: The competition categories were public, but exact scoring weights and tie‑breaker rules were not disclosed in event materials.
• Reproducibility outside AWS: The format is transferable, but the turnkey experience depends on AWS tooling used in the league; organizations on other clouds will need equivalent infrastructure and facilitation.
• Fine‑tuning specifics: Organizers referenced an RL‑style fine‑tuning workflow called “RLVR” (Reinforcement Learning from Verifiable Rewards); event materials used that shorthand but did not provide dataset sizes, model families or runtimes.

Key takeaways, common questions and short answers

• How quickly can a large engineering team get practical with agentic AI?

  According to Atos and AWS, you can move hundreds of engineers from awareness to hands‑on demos in days using a focused, competitive workshop, but expect 3-6 months of follow‑up work to productionize winning prototypes.

• What does a hands‑on agentic AI exercise teach that slides don’t?

  It forces real trade‑offs under constraints, prompt economy, tool vs. model boundaries, guardrail tuning and observability, making architectural decisions and consequences tangible.

• Which services and skills emerged as essential?

  Organizers emphasized Amazon Bedrock and Bedrock AgentCore for agent orchestration, Bedrock Guardrails for safety, AWS Lambda for deterministic tools, and SageMaker for targeted fine‑tuning, plus solid logging and telemetry practices.

• What governance pitfalls should leaders watch for?

  AWS documentation calls out that some gateway auth modes log JWT claims in CloudTrail; avoid putting PII in those claims, apply least‑privilege IAM and plan audit and retention policies before you ramp pilots.

• Does a competitive format scale for enterprise upskilling?

  Yes, when coupled with turnkey facilitation and clear post‑event pathways. Competitions surface champions and reusable patterns quickly, but leaders must invest in governance and pilot funding to capture long‑term value.

Final thought

Atos and AWS used constraints, time limits, lives, token budgets and a scored leaderboard, to force engineers to move from knowing about agentic AI to building working, production‑relevant demos. That pressure helped surface practical design patterns, security trade‑offs and observability requirements fast. Use a league to create momentum and champions, then commit the resources to harden, govern and measure pilots so the learning converts into durable capability.