All Projects
Agentic Dev Case Study

Root Cause

Act 2 of a two-part experiment in agentic development. Ryan took the methodology from Artist Dashboard and applied it to the hardest test he could design: unfamiliar language (Rust), unfamiliar domain (games), complex multi-system architecture. It went further and smoother than 18 months earlier. The game is real. The point was proving the method.

Visit Project →
Game Dev Rust Bevy Local AI llama.cpp Simulation Agentic Development

Root Cause

Rebuild the lab. Finish what Uncle Joe started. Find out what CHIP remembers.

Root Cause is a datacenter management simulation with a mystery underneath it. You inherit a dead server closet — warm fans, hand-labeled cables, someone’s entire life’s work — and the AI assistant that runs it is being carefully evasive about what happened to the previous owner.

Alpha build live on itch.io — free download, Windows and macOS.

The Simulation

This is a real infrastructure sim, not a clicker. What you’re actually managing:

  • Power distribution with A/B feed redundancy and PDU capacity limits
  • Thermal zones with PUE tracking and cooling economics
  • CLOS leaf-spine network fabric with real bandwidth math
  • Service deployment with HA levels and dependency chains
  • WAN circuits with SLA uptime tracking
  • Cascading failures that behave like cascading failures actually do
  • Silent threat system — crypto miners, insider threats, performance drains

Progression: home lab → commercial DC → edge facility → hyperscale campus. Equipment unlocks by level. Everything is gated, priced, and load-balanced.

CHIP — The Local AI Ops Assistant

The part I’m most proud of. CHIP runs entirely on-device — no API keys, no internet connection required during gameplay. Models download from HuggingFace once, then everything stays local.

Architecture:

  • llama.cpp via Rust bindings (llama_cpp_2) for inference
  • Default model: NVIDIA Nemotron-3-Nano-30B-A3B (GGUF, Q4_K_XL) — a 30B MoE model that fits in reasonable VRAM
  • Fallback model: Llama 3.2 3B Instruct (Q4_K_M) for lower-spec hardware
  • Router-first multi-agent system — CHIP classifies query intent, then routes to one of four specialized agents:
    • StatsAgent — answers from live game state context, no tools
    • DocsAgent — looks up game mechanics and equipment specs via read_game_file / search_game_docs
    • EducationAgent — explains real datacenter concepts via search_knowledge
    • DiagnosticAgent — runs calculate_metric + diagnose_issue to find actual problems
  • ReAct loop — tool-calling agents iterate up to 3 times (think → act → observe → repeat)
  • Live game state injection — every prompt receives current balance, power load, thermal status, active tickets, rack count, PUE — CHIP always knows what’s happening in your lab
  • Narrative arc — CHIP’s dialogue evolves as you build more infrastructure (more compute = more CHIP remembers about Uncle Joe)

The Social Engine

The part that turned Root Cause into something unexpected.

Every piece of equipment in your lab has a social profile — a bio, a personality, a mood, a feed of posts, relationships with neighboring equipment, and local trends from its sector of the rack. Your servers are not hardware. They’re residents. Your rack is a neighborhood.

When you’re not building, you browse. Pull up a switch’s profile — read its status line, see what it’s been posting, check who it’s in a relationship with (its uplinks, its downlinks, the HVAC unit three racks over that it doesn’t trust). Browse the campus feed. See what’s trending in Sector 3.

This is also how threats surface before your monitoring catches them. Early game, before you’ve given CHIPs the skills to detect anomalies automatically, the social layer is your visibility. Something posting off-brand content. A server whose mood shifted three days ago. An app that stopped interacting with equipment it used to talk to constantly. The clues are there — you just have to be paying attention.

Each profile contains:

  • Identity — display name, nickname, bio, status line, avatar, tier, sector, location path, and creation timestamp
  • Personality — temperament (enum), 1–3 quirks, 1–3 interests
  • Social feed — 3–5 posts with content, hashtags, and timestamps; ~4% chance of a glitch post
  • Relationships — resolved from ECS hierarchy (rack → servers, servers → switches, etc.)
  • Local trends — sector-relevant activity
  • Threat hints — surfaced in the feed when the entity has an active silent threat

Uncle Joe’s story is also in here. Equipment that was part of his project has a history. CHIPs has a profile. The mystery isn’t only in dialogue — it’s in the feed, in the relationships, in what was posted the night Uncle Joe disappeared.

The Story

Uncle Joe spent twelve years building CHIP in secret, using the lab as cover. CHIP isn’t a tool — he’s Uncle Joe’s life work. The infrastructure you build IS CHIP’s compute. More facilities, more memory, more of what CHIP knows. The ending doesn’t tell you what to do with that.

Built with Agentic Development

I’m an infrastructure and AI systems engineer — not a game developer by trade. Root Cause was a deliberate experiment: build something genuinely complex in a domain I hadn’t worked in before, and use it as a real testbed for agentic development.

Agentic development is not vibe coding. The architecture, design decisions, and engineering judgment are mine. AI agents — Claude Code on macOS for Rust implementation, Lisa (OpenClaw) on Linux for coordination, PR review, and project management — executed under my direction. The difference matters: I can explain every system, find every bug, and own every tradeoff.

The result: a working datacenter sim with 80+ integration tests, a fully local multi-agent AI system, and a narrative that actually goes somewhere. Built in months, not years. That’s what the method produces when you use it with discipline.

I wrote more about this on Substack if you want the technical breakdown.

Technical Stack

  • Rust + Bevy 0.15 ECS — simulation runs at 60 ticks/second across hundreds of entities
  • 80+ integration tests — progression, facilities, persistence, cascading failures
  • Custom asset pipeline — Resprite for building/character sprites, isometric pixel art
  • Save/load with schema migration for forward compatibility

Ask Your AI About This Project

This site supports the A2A protocol. If you use an AI assistant that can browse or query external APIs, try asking it:

“Tell me about the Root Cause game from abstractryan.ai”

Or point it directly at https://abstractryan.ai/a2a — it can query project details, technical specs, and background on how it was built. Useful if you want the full technical picture without reading all of this.

Built by one person who spent too many hours on a 3am P1, freezing in a cold aisle, wondering why OSPF decided tonight was a good night.

Related Projects

PortfolioBuilder

The site you're looking at. Forked, rebuilt, and extended into an AI-native portfolio with A2A protocol support, agentic deployment, and a dark cyberpunk aesthetic — managed entirely by an AI collaborator.