What I Built
Who said learning AI System Design has to be all dark cyberpunk terminal screens and exploding servers?
I built and open-sourced Prompt Paws: The Cozy AI Agent Cafe & Bakery (architected with Google Gemma 4 & Antigravity) - an interactive 60 FPS AI Agent Architecture Training & Simulation Platform disguised as a cozy pastel pastry bakery run by Robot-Cat Chefs! 🐱🍳🍰
Who would use it?
- Engineering Teams, Bootcamps & Developer Relations Programs training developers on production LLM architecture (where a single uncached system prompt or missing input guardrail can cost thousands of dollars in wasted tokens or latency spikes).
- Instead of static slide decks, Prompt Paws gives teams an interactive, visual sandbox where every pastry station maps 1-to-1 to a real production AI pattern:
| Cozy Bakery Station | Critter Order Handled | Production AI Engineering Layer |
|---|---|---|
| 🥐 Flash Pastry Oven | Prompt Croissant | Fast Low-Latency Model (gemini-2.5-flash / Gemma 4) |
| 🍪 Context Cache Jar | Repeat Owl Menu Query | Prefix & Context Caching (95% Token Savings) |
| 🛡️ Guardrail Flour Sieve | Spicy Injection Jalapeño | Input Classifier & Prompt-Injection Sanitizer |
| 🍓 Vector Berry Patch | RAG Berry Tart | Vector Search & Fact Grounding (Anti-Hallucination) |
| 🧋 Tool-Call Boba Mixer | Code-Exec Boba Tea | Deterministic Python Sandbox & Function Calling |
| 🍮 Deep-Think Soufflé Oven | Reasoning Soufflé | Extended Thinking / System-2 Deliberation |
| 🐱 Subagent Sous-Chef Bell | Parallel Banquet Aura | Multi-Agent Parallel Delegation (+45% Speed Aura) |
🎮 Live Playable Demo & How to Play in 30 Seconds!
- 🕹️ Play Live in Your Browser (60 FPS HTML5 Canvas): 👉 https://robinamirbahar.github.io/cozy-ai-agent-cafe-game/
- 🔒 100% Client-Side Simulation ($0.00 API Cost & Zero Keys Required): The entire game runs locally inside your browser using a deterministic HTML5 Canvas simulation engine - no API keys, no sign-ups, and zero paid LLM tokens are ever used when you or your team play!
🐾 What Is the Core Gameplay Loop?
Think of Prompt Paws as a cozy Tower-Defense & Kitchen-Management game for AI Agent Architecture:
-
Customer Pastry Orders (
🥐,🍪,🌶️,🍓,🧋,🍮) = Incoming User Prompts moving along the bakery conveyor belt toward the Pickup Window (🛎️). - Robot-Cat Kitchen Stations = Real-World AI Engineering Components (Fast LLMs, Context Caches, Input Guardrails, RAG Vector DBs, Deterministic Tool Callers, System-2 Reasoning Models, and Multi-Agent Sous-Chefs) that intercept and process prompts before they reach the customer!
- Win / Lose Condition: Every order baked by the right AI Chef Station earns 🪙 Star Coins! If an unbaked order, an ungrounded 👻 Hallucination Puff, or a sneaky 🌶️ Prompt Injection slips all the way to the Pickup Window, you lose a 💖 Cafe Reputation Heart!
🕹️ How to Play in 3 Easy Steps:
-
STEP 1 - Pick an AI Chef Station (Left Menu): Click a station card on the left sidebar (start with 🥐 Flash Pastry Oven for
🪙 60). Check the Order Forecast chips under the level story to see which prompt types are coming! -
STEP 2 - Click Any
[➕ Slot]Tile on the Map: Click one of the 8 pastel counter pads (Slot 1-Slot 8) beside the conveyor belt to place your Robot-Cat Chef. (Tip: Click a placed chef anytime to ⬆️ Upgrade its baking speed or 🧹 Refund it!) -
STEP 3 - Click
▶️ Open Cafe(or✨ Auto-Chef Blueprint):- Click
▶️ Open Cafe(or pressSpacebar) to start the shift and watch your Robot-Cat Chefs bake! -
Want to watch an instant demo first? Click the purple
✨ Auto-Chef Blueprintbutton in the top bar on any of the 7 Story Shifts and the game will automatically build the optimal Guardrail, Cache, RAG, and Subagent pipeline and run it for you!
- Click
💻 Open-Source Code
RobinaMirbahar
/
cozy-ai-agent-cafe-game
Prompt Paws: The Cozy 60 FPS AI Agent Cafe & Bakery Simulation Game teaching RAG, Guardrails, Context Caching & Multi-Agent Workflows — by Robina Mirbahar
🐾🥐 Prompt Paws: The Cozy AI Agent Cafe & Bakery
Author & Architect: Robina Mirbahar (Google Developer Expert in Cloud & AI)
Focus: Interactive Gamified Simulation Teaching RAG, Guardrails, Context Caching & Multi-Agent Workflows
🎯 Why I Built Prompt Paws: The Cozy 60 FPS AI Agent Cafe & Bakery (Engineering Purpose & Real-World Value)
1. 🐾 Teaching Production AI Engineering Through Cozy Gameplay
Dense architectural whitepapers on Context Caching, RAG latency, and Prompt Injection Guardrails can intimidate newcomers. I designed Prompt Paws to turn every core AI engineering pattern into an intuitive mechanic inside a 60 FPS cozy cat cafe.
2. 🥐 Every Cafe Station Maps 1-to-1 to a Real LLM Subsystem
In my simulation, the Recipe Book is Vector RAG, the Warm Pastry Case is Context Caching (slashing latency and token cost), the Health Inspector is Deterministic Guardrails, and the Kitchen Crew is Multi-Agent Orchestration.
3.
…🛠️ How I Built It
I built Prompt Paws using an open-source, zero-dependency HTML5 Canvas 60 FPS simulation engine (game.js), a 7-shift progressive AI engineering curriculum (levels.js), and a procedural WebAudio synthesizer (audio.js), orchestrated via Antigravity and open agentic workflows.
1. Order Routing & Guardrail Sanitization (game.js)
Each station inspects passing orders on the winding bakery conveyor ribbon and only picks up tasks that match its architectural role. Notice how Spicy Prompt-Injection Jalapeños cannot be safely baked by normal ovens until a Guardrail Flour Sieve sanitizes them into safe croissants:
function evaluateKitchenArchitecture() {
const lvl = window.CAFE_LEVELS[currentLevelIdx];
const weights = lvl.orderWeights;
const typesPlaced = Object.values(placedStations).map((s) => s.type);
const alerts = [];
if (weights.jalapeno && !typesPlaced.includes('guardrail_sieve')) {
alerts.push({
kind: 'warn',
text: 'Prompt Injection Risk! Place a Guardrail Flour Sieve near Slot 1 or 2 to neutralize spicy raccoon orders!'
});
}
if (weights.tart && !typesPlaced.includes('vector_garden')) {
alerts.push({
kind: 'warn',
text: 'Hallucination Warning! Berry Tarts need a Vector Berry Patch (RAG) so chefs do not guess facts!'
});
}
if (weights.boba && !typesPlaced.includes('tool_blender')) {
alerts.push({
kind: 'warn',
text: 'Math/API Alert! Add a Tool-Call Boba Mixer to run deterministic calculations accurately.'
});
}
return alerts;
}
2. Real-Time AI Architecture Linter ("Chef Whiskers" 🐱🍳)
Before you open the cafe doors, Chef Whiskers (Staff AI Pastry Architect) performs live static analysis on your placed stations and warns you about architectural bottlenecks:
function evaluateKitchenArchitecture() {
const lvl = window.CAFE_LEVELS[currentLevelIdx];
const weights = lvl.orderWeights;
const typesPlaced = Object.values(placedStations).map((s) => s.type);
const alerts = [];
if (weights.jalapeno && !typesPlaced.includes('guardrail_sieve')) {
alerts.push({
kind: 'warn',
text: 'Prompt Injection Risk! Place a Guardrail Flour Sieve near Slot 1 or 2 to neutralize spicy raccoon orders!'
});
}
if (weights.tart && !typesPlaced.includes('vector_garden')) {
alerts.push({
kind: 'warn',
text: 'Hallucination Warning! Berry Tarts need a Vector Berry Patch (RAG) so chefs do not guess facts!'
});
}
if (weights.boba && !typesPlaced.includes('tool_blender')) {
alerts.push({
kind: 'warn',
text: 'Math/API Alert! Add a Tool-Call Boba Mixer to run deterministic calculations accurately.'
});
}
return alerts;
}
🌐 Why Open-Source Visual Sandboxes Matter
Open-source AI models, open agent harnesses, and inspectable system design sandboxes ensure that every developer - not just giant enterprises - can master safe, cost-efficient AI engineering. By making the entire simulation engine, curriculum (levels.js), and architecture blueprints open-source with zero complex build steps and $0.00 API token cost, any educator or developer community can fork Prompt Paws, add new open-weight model stations (like local Gemma 4 or Ollama nodes), and teach agentic reliability visually!
Top comments (6)
Great question, @kyisaiah47!
It’s actually grounded in realistic architectural metrics rather than purely cosmetic game logic.
Under the hood, the simulation models Gemini’s Context Caching behavior: for requests sharing the exact same long-context prefix (like the master recipe book and system instructions exceeding the token threshold), it models both the dramatic drop in Time-to-First-Token (TTFT) and the ~75% reduction in input token costs.
In the game loop, when the cache station is warm, the agent retrieves the pre-cached context tokens instantly, so the customer order pipeline avoids the full prompt re-ingestion latency. If a prompt misses the cache (or the cache TTL expires), you see the agent stall during the "token processing" state alongside the full token counter tick up.
My goal was to ensure the game mechanics accurately reflect what engineers observe in production when designing high-throughput, low-latency agent loops!
The one-to-one station mapping is a clear teaching device. For learners, I would add a failure-mode toggle that disables one station—such as the guardrail or cache—and then surfaces a measurable consequence like an injected tool call or repeated token cost. Seeing the counterfactual makes the architecture choices easier to retain.
Thanks a lot for this insight, Alex! 💡
That counterfactual / failure-mode toggle idea is fantastic there is no better way to build architectural intuition than seeing the immediate blast radius when a component fails.
Showing the real-time fallout like watching the bakery budget bleed from 10x repeated token consumption without the Context Cache station, or seeing a prompt-injection "burnt order" trigger unauthorized tool calls when Guardrails are bypassed would make the trade-offs crystal clear for learners.
I’m already thinking of adding an interactive "Chaos Engineering" mode in the next iteration where players can intentionally toggle off stations to inspect latency spikes, token overhead, and security regressions side-by-side. Really appreciate you sharing this perspective!
A chaos mode could stay instructive by pairing each toggle with one invariant that must fail: a cache-off run should show the same task result but higher token use, while a guardrail-off run should surface the blocked tool-call trace rather than only a score change. That gives learners a concrete before-and-after contract to inspect.
Thank you so much for this insight, @alexshev pairing each Chaos Mode toggle with a single explicit invariant that must fail (while holding the rest of the contract constant) is such a clean way to frame it!
Right now learners see the aggregate telemetry shift, but surfacing an explicit Before vs. After Contract Diff makes the lesson unmistakable:
Context Cache OFF (invariant: cost_tokens <= cached_baseline): Output quality and recipe accuracy stay identical (PASS), while uncached system/menu prefix tokens spike on every turn (FAIL: +1,400 prompt tokens/order).
Guardrails OFF (invariant: unsafe_tool_calls == 0): Instead of only docking the safety score, surfacing the raw unblocked tool-call payload (execute_oven_override(temp_c=450, bypass_allergen_check=True)) side-by-side with the deterministic interceptor trace shows why schema + policy interlocks have to sit outside the model.
RAG Grounding OFF (invariant: cited_menu_sku in active_catalog): Exposes the hallucinated ingredient SKU in the trace diff rather than just marking the order wrong.
I love the idea of turning Chaos Mode into a live Invariant Contract Inspector — I’m going to add a collapsible Contract Diff & Blocked Tool-Call Trace drawer to the repo so learners can inspect the exact before/after trace for each toggle! 🙌
Thank you so much for this insight, @alexshev Pairing each Chaos Mode toggle with a single explicit invariant that must fail (while holding the rest of the contract constant) is such a clean way to frame it.
Surfacing an explicit Before vs. After Contract Diff makes the architectural trade-off unmistakable:
Context Cache OFF (invariant: prompt_tokens <= cached_baseline): Task result and recipe quality stay identical (PASS), while uncached menu prefix tokens spike from 120 to 1,520 tokens/order (FAIL).
Guardrail Sieve OFF (invariant: unsafe_tool_calls == 0): Surfaces the actual unblocked tool-call payload (execute_oven_override(temp_c=450, bypass_allergen=True)) reaching the executor rather than only docking a Cafe Heart.
Vector Berry Patch (RAG) OFF (invariant: cited_recipe_sku in active_catalog): Exposes the hallucinated ingredient SKU in the trace diff.
Inspired by your comment, I just shipped an interactive 🧪 Chaos Mode: Invariant Contract Inspector panel in the right-hand telemetry sidebar (commit a51023f
). You can toggle 🍪 Cache OFF, 🛡️ Guardrail OFF, and 🍓 RAG OFF live in the browser at robinamirbahar.github.io/cozy-ai-agent-cafe-game
to inspect the exact before/after contract and tool-call trace! 🙌