An AWS hybrid AI demo from the CEE community event — and we keep diving deep

Thursday, Budapest, AWS Community Day CEE. One session I had circled for a week: ninety minutes, hands on keyboard, building a small agentic role-playing game with Strands Agents, the open-source agent SDK. A game master, dice over MCP, a rules expert and a character keeper over A2A, and a browser UI.

I did the workshop. Then I took the finished lab home and pointed it at my own hardware. By early afternoon the same game was running in my own datacenter, on my own GPUs, with no internet access at all.

Everything you see on this blog is cooked in-house. The image above was generated on my own GPUs, offline — no stock photography, no cloud image API. Recipe at the bottom.

Why this game is a strong hybrid demo

A good demo is small enough to read in an afternoon and complete enough to be honest. In a few chapters this one builds an agent loop, a tool served over MCP, two agents talking over A2A, retrieval over a rulebook, and a typed JSON contract for the web UI. That is the shape of a real agent system, minus the business logic.

It is also the first architecture I have seen where the hybrid argument makes itself. Exactly one piece of the game lived in the cloud: the model call. The agent loop, the dice tool, the MCP server, both sub-agents, the vector search over the rulebook, the character store and the UI already ran on my machine. Moving the inference to my own GPUs was a configuration change, not a port.

And because it is a game, failures are visible: a skipped step looks fine in a support-ticket demo, but you can see that the die was never rolled.

What we learnt

The seam is the model provider. One object decides whether inference happens in a hyperscaler’s region or in my rack; everything above it — tools, memory, protocols, UI — is mine either way.

The first thing that broke was not the model. It was the request shape: the SDK sends an empty tools array for a tool-less agent, and one vLLM version rejects it while another accepts it. A ten-line subclass fixed it. The surprises sit in the plumbing, not in the intelligence.

Tool-call fidelity is the number that matters, and almost nobody measures it. My small local model narrated dice rolls it never made, invented an address for a sibling agent, and once claimed to have created a character that was never stored. The large model on my own cluster did the same task exactly. Same code, same prompts, different truthfulness. So I wrote a harness that counts tool calls and compares what the model says with what the tools returned. That, not a benchmark score, is the test I trust.

Forcing a typed answer made the small model worse. Given a strict JSON output schema, it filled the schema in directly and stopped calling tools. Structure is not free.

Tool design beats model size. The MCP dice tool takes a count argument, so “roll four dice” is one honest call. The hand-written version rolls one die per call and needs sixteen for a character, which is exactly where the small model gave up and started inventing.

Some failures are design bugs, not model limits. The sample’s character agent is told to roll dice for ability scores and has no dice tool, so its numbers are invented on any model. Watching every call revealed it; reading the narration never would.

Pin your versions. The workshop’s own steps stopped working mid-week because an upstream dependency moved a major version: two renamed imports, two chapters that fail before they start.

Which AWS technology runs locally

• Strands Agents, the Apache-2.0 agent SDK that AWS publishes: agent loop, tool definitions, MCP client, A2A server and client, typed output, model-provider abstraction. All of it runs in my own process.
• The workshop’s sample game, MIT-0 licensed, forked into my own git.
• Two open standards the SDK speaks, MCP for tools and A2A between agents, both entirely on my side.
• The model call. The sample’s default provider is Amazon Bedrock; in my copy that one call goes to my own gateway and GPUs. It is the only thing I changed.

So the agent framework from AWS runs locally, and no AWS service runs in my copy at all. That is the hybrid idea: build the agent with the tooling you like, then decide per workload where the inference happens.

The whole lab now lives in my datacenter

A demo must not depend on a workshop link, an event account or conference Wi-Fi, so I captured all of it: code in my own git, an image in my own registry, dependencies pinned to the versions that worked, fonts self-hosted, the rulebook embedding model baked into the image, phone-home telemetry off.

The container sits on an isolated network with no route to the internet; a small relay is the only door, UI in, AI gateway out. Verified from inside the container: the public internet is unreachable, and a game turn still plays. Later demos run from this copy.

What’s next

This is now my standing demo for hybrid AI workloads. Next:

• A Strands Agents deep dive — multi-agent patterns, structured output, and whether its model-routing layer can fall back from a local model to a cloud one per request.
• The honest comparison — the same agents on two backends, measured for tool-call fidelity rather than adjectives. I am building this pattern on a real customer case, so the numbers will come from work, not from a toy.
• More advocacy, less slideware. Agents where they are easiest to build; inference where the data has to stay. If that is your constraint too, I would like to compare notes.

Thanks to the regional AWS User Groups community, organised by LaniSys Kft., and to community founder Mihály Balassy, for a day worth the trip, and for a workshop whose output is still running, hours later, in a rack I own.

Feature image made in my lab — image model, prompt and settings

Image model

Qwen-Image, served from my own GPU node behind my AI gateway

Generated on

My own GPUs, offline — my hardware, my electricity, nothing leaving the building

Settings

1344×768, single pass, server defaults

Prompt

A wide editorial photograph telling one story in two halves: cool daylight through a glass atrium where translucent abstract shapes drift like software agents; a dark private machine room with racks of GPU servers, status LEDs glowing amber; between them a single taut cable of light carrying particles in both directions. Closing with the style tail shared across this blog: moody editorial hardware photography, cold blue and cyan light with a single warm accent, shallow depth of field, 50mm, dark background, fine detail, cinematic, high dynamic range, no text

Amazon Web Services and AWS are trademarks of Amazon.com, Inc. or its affiliates. ATAILA is not affiliated with, sponsored by, or endorsed by AWS.