This series documents what we learned building a production AI agent runtime and Aiden — StackGen’s multi-tenant orchestration platform for enterprise SRE and platform teams. Every post is grounded in shipped behavior and production failures, not demo polish.

Start here: Go vs Python for AI Agents — Why We Chose Go

Topic hubs

Dive by theme:

Full series (reading order)

# Post Summary
1 Go vs Python for AI Agents — Why We Chose Go Go vs Python for production AI agents — concurrency, deployment, and when you shouldn’t follow our path.
2 TOML Over YAML and PKL — How We Stopped Fighting Config and Started Shipping We tried YAML, considered PKL, and landed on TOML for agent configuration. The reason surprised us.
3 Architecture at Speed Without Drowning From a single Hello World commit to a production Go codebase in a few months — the architecture patterns that made rapid development sustainable.
4 Implementing ReAcTree — 6 Production Bugs the Paper Didn’t Warn You About What happens when you take an arXiv algorithm to production. We found 6 bugs that no paper mentions.
5 Pensieve — Memory Management for AI Agents That Actually Forget Your agent remembers everything. That’s a bug, not a feature. Here’s how we built a memory system that learns, forgets, and self-prunes.
6 Teaching Agents to Learn Without Fine-Tuning Post-session skill distillation from agent traces — how we teach agents to write their own runbooks.
7 The HITL Paradox — When Human Approval Makes Agents Worse Human-in-the-loop is supposed to make agents safer. It can also make them useless. Here’s how to find the balance.
8 Your Agent Has Root — Defense-in-Depth for AI Agents That Wield Real Tools Your agent can run rm -rf /. Your prompt saying ‘don’t do that’ is not security. Here’s why one layer is never enough.
9 You Can’t Debug What You Can’t See — Observability for AI Agents Observability for production AI agents — session traces, tool attribution, and token budgets beyond traditional APM.
10 Terraform for Agent Configuration — Infrastructure as Code Meets AI Governance We use Terraform to configure our AI agents. Not YAML. Not a dashboard. Terraform. Here’s why.
11 Why We Split Our Agent Runtime From Our Platform Why we split the agent runtime from Aiden — multi-tenant enterprise AI agent platform architecture in Go.
12 Contributing Back While Building a Commercial Product We built a proprietary product. We also merged 17 PRs into the agent framework we depend on. Here’s how to navigate that tension.
13 Why One JSON Repair Pass Isn’t Enough for Production Agent Tool Calls Production AI agent tool calls need layered JSON repair — why one pass fails and what we learned in Go middleware.
14 Prove, Then Narrate — Deterministic Orchestration Over Autonomous Agents Evidence-gated multi-plane RCA — fixed DAG, structural evals, and token-aware tool loops for production agent workflows.
15 AI Incident Triage for SREs — What Actually Helps On-Call AI incident triage for SREs — what actually helps on-call versus demo theater, grounded in parallel context gathering in Go.
16 Evidence-Based Verification — Don’t Trust Self-Report, Check the System Evidence-based verification for AI agents — pull proof from ArgoCD, Datadog, and systems of record; let Go own pass/fail.
17 Maintaining Tokenomics with Aiden — Context Budgets as an Operating Model LLM tokenomics for production AI agents — context budgets, tool compression, and FinOps loops that keep sessions finishing.
18 How to Debug Multi-Stage AI Agent Workflows — Bring Up Like Hardware Debug multi-stage AI agent workflows by bringing up one stage at a time against golden gates — plus why scoring tool calls beats grading transcripts.

More on this site

Posts outside the numbered series (e.g. cloud entitlements, web→LLM metrics) live on the homepage archive.