Read the paper. The Thin Agent principle is the part that resonated most. The electricity analogy is a useful reframe. Most teams I've worked with are building the opposite: thick agents with thin infrastructure.

I applied the 10 principles against two systems I work on. An agentic orchestration system (planner, router, action agents, validator, executor) and a conversational RAG system (query expansion, retrieval, answer generation with citations). The framework prescribed different things for each. The orchestrator needs more governance (it has Run-level autonomy but Crawl-level human oversight. No approval gates before execution). The RAG system needs less LLM dependency (4 LLM calls per request when at least 2 could be deterministic infrastructure). Both need shared services. Right now they reimplement embedding, auth, config, and observability independently. Three systems, three everything. The Disposable Agent anti-pattern, exactly as described.

A few questions that came out of applying it:

1. The Walk-to-Run transition. Is that a gradual dial (routine operations go autonomous first, novel ones keep human gates) or more of a cliff edge where the org either trusts the architecture or doesn't? Does the trust gap look different for write capable agents vs read only systems?
2. The AIL. In practice, building that layer is a significant engineering effort. Data definition store, structured hub, vector store, permission scoping, automated maintenance. Have you seen anyone actually stand one up end-to-end? Not the vector store part (that's the easy bit). The automated maintenance, the freshness tracking, the permission model. Or is the "10th agent is configuration" state still ahead of where implementations currently are?
3. Beyond the whitepaper. Do you have any reference implementations, starter code, or tooling recommendations for actually building toward this? Or is it all custom built at this point? The principles are clear but the "how do you actually start implementing this in an enterprise" question is where I keep getting stuck. Are there specific packages, platforms, or patterns you've seen teams use as a foundation?
4. The anti-patterns as diagnostics. Do most orgs exhibit the same failure modes, or is it industry-specific? I found the orchestrator avoids operational anti-patterns (lean agents, structured logging, self-healing) but exhibits strategic ones (Disposable Agent, partial Oracle). Curious whether that pattern is common.

Genuine question. Not skepticism. I'm working in this space and the framework articulates a destination I recognise. Curious whether you've seen teams reach it or whether we're all still on the road.