We’ve Mistaken Architectural Complexity for Intelligence
Open LinkedIn on any given morning and you’ll find a new diagram. Seven boxes stacked vertically. Arrows pointing up. Labels like “Orchestration Layer,” “Vector Memory Layer,” “Agent Execution Layer,” “Trust & Safety Layer,” and a color gradient that says this is serious infrastructure thinking.
The AI layer cake has become the dominant mental model for how people explain building with AI. Every consulting firm has its version; every VC memo echoes it, and every conference keynote refines it slightly, calling it the next big thing. The details shift, new layers get added, names change, but the core idea never does: AI is something you assemble, bottom to top, until intelligence magically appears at the top of the stack.
The diagrams are beautiful. They’re coherent. And they’re mostly wrong about how this actually works in production.
The Pundit Version of AI Is a Layer Cake
The premise is seductive: building with AI is a structured engineering problem. Pick your infrastructure (bottom layer), select your foundation model (middle layer), wire up your orchestration framework (another layer), add a RAG pipeline and vector store (two more layers), wrap it in a safety and trust layer, and serve through your application layer at the top. It’s all very neat, reproducible, and productizable.
The problem is that very few production AI systems actually look like this.
ZenML analyzed over 1,200 real-world LLM deployments and found that for a wide range of use cases, calling the model directly was simpler, faster, and more predictable than using any layered framework. The most popular orchestration framework was described in that analysis as “rather heavy” and “overkill for simple RAG or single-call use cases.”¹
Microsoft’s internal engineering team was even blunter: the most common mistake they see is teams adopting complex agentic architectures and frameworks before they’ve validated whether they actually need that complexity. They call it “unearned complexity” and they recommend starting with the simplest thing that works before reaching for the scaffolding.²
Translation: don’t build the six-layer cake until the problem actually requires six layers.
Most Production AI Is Embarrassingly Simple
A good model, a well-written prompt, and relevant context. That’s it.
Not because the people building with AI aren’t sophisticated; the models have simply gotten good enough that most of the scaffolding in those diagrams is doing work the model was already doing natively. Engineers are building elaborate tool-routing logic, complex retry systems, and multi-step orchestration pipelines to solve problems that a well-named function and a clear system prompt would have handled. The orchestration layer is solving problems the LLM wasn’t actually having.³
I see this constantly in healthcare. Teams building six-node pipeline graphs to do prior authorization extraction or clinical note summarization that a structured prompt and a single API call would nail. The complexity wasn’t warranted; it was inherited from a diagram.
So why do we over-engineer when we don’t need to? Engineers don’t build these monolithic stacks out of naivety. They do it because of systemic incentives:
- Resume-Driven Development (RDD): Writing a brilliant, deterministic system prompt and a single clean API call doesn’t get an engineer promoted. Architecting an “Autonomous Multi-Agent Orchestration Subsystem” does.
- The VC Illusion: Venture capitalists rarely fund a startup whose primary intellectual property looks like a single python script. The layer cake is frequently built to manufacture artificial enterprise value on a slide deck.
Somewhere along the way, the industry started confusing complexity with maturity.
The Mismanaged Genius Problem
This structural over-engineering masks a deeper, more fundamental flaw in how we view current AI capabilities. We treat frontier models like components to be wired together, rather than realizing that the core model is already a “genius” trapped inside a deeply sub-optimal management structure.
This is what researchers Alex Zhang, Zhening Li, and Omar Khattab have named the “Mismanaged Genius Hypothesis (MGH).” It suggests that our current frontier models possess staggering, near-superhuman capabilities across a broad array of disciplines, yet they frequently stumble on long-horizon, iterative tasks. The temptation is to assume this is a fundamental limitation of the model itself, prompting us to build heavier layer cakes to “guide” it.
MGH argues the exact opposite: the model isn’t failing; our rigid, human-engineered agent scaffolds are mismanaging it.
When we design brittle, task-specific pipelines (the layer cake methodology), we are applying our own flawed human intuitions about how a problem should be decomposed. We restrict the model’s action space to rigid API calls and static graph nodes. In doing so, the human-engineered framework becomes the limiting bottleneck, choking the model’s ability to dynamically adapt, self-correct, and navigate out-of-distribution (OOD) tasks.
Cultivate. Don’t Build.
Here’s the mental model I’d offer instead of the layer cake: look at your AI system less like static software and more like a living thing. More specifically, think of it like a sourdough starter.
A sourdough starter isn’t just an ingredient. It’s a living culture that adapts continuously to its environment. You don’t micromanage every bubble, every rise, or every fermentation cycle with an elaborate external control system.
What this means for AI is that you create the conditions for intelligence to emerge and sustain itself. The starter metabolizes inputs, self-regulates, strengthens over time, and develops distinct behaviors based on interaction, feedback, and memory.
The best AI architectures are not the ones with the tallest stacks or the most orchestration layers. They’re the ones that match the complexity of the recipe to the task.
For example, some problems are fat skill, thin harness. Complex reasoning, clinical judgment, and long-context synthesis are like great sourdough: the outcome depends primarily on the quality of the starter itself. You do not compensate for a weak starter with more kitchen equipment. You improve the ingredients, refine the fermentation process, and allow the culture to mature. In AI terms, that means better models, better context, better prompts, and better feedback loops, not endless orchestration layers wrapped around the system.
Other problems are fat harness, thin skill. The reasoning is simple, but the coordination burden is high: workflows, tools, approvals, memory, retries, and state management. That’s where orchestration genuinely matters.
The mistake is building a fat harness around a fat skill problem. That adds engineering complexity without adding capability. It creates brittle systems, impressive diagrams, and engineering theater around intelligence the model already possesses.
The real breakthrough happens when models begin managing more of that complexity themselves: decomposing tasks, refining intermediate outputs, recovering from errors, and recursively improving execution.
A Few Layers Are Genuinely Non-Negotiable
I’m not arguing that structure doesn’t matter. Some things are real:
Grounding. Without relevant context, the best model hallucinates confidently. Grounding ensures the model is anchored to trusted sources, structured knowledge, live data, or actual operational context.This is non-negotiable.
Observability. You cannot improve what you cannot measure. Simon Willison has been writing about this longer than most, and he’s right: building good automated evals for your LLM-powered system is now the most important engineering skill in production AI.⁴ If your eval suite is strong, you can adopt new models faster, iterate better, and build more reliable products than anyone still optimizing their orchestration layer.
Security at the boundary, especially in healthcare. Patient data handling, access control, and audit trails are not layers you debate. They’re table stakes.
Everything else is conditional. The orchestration layer is real, for the problems that need it. The vector store is real, for the retrieval problems that justify it. Outside those foundations, the more interesting shift happening now is that teams are moving away from heavy, opinionated frameworks toward thinner SDKs and direct model interaction. Thin SDKs and direct API calls are consistently beating monolithic frameworks in production deployments.
Anthropic’s Model Context Protocol is a signal worth paying attention to here: a standardized tool interface that removes the need for framework-specific connectors. One protocol that works everywhere. The fact that it got broad, fast adoption, and was subsequently donated to the Linux Foundation’s Agentic AI Foundation, tells you something about how much unnecessary complexity the industry had been carrying.⁵
Start the Starter
The layer cake isn’t wrong about the individual components. Infrastructure, models, and grounding are entirely non-negotiable. What organizations fundamentally get wrong is the metaphor. It implies a universal blueprint where more structural layers automatically equal more capability.
The reality is the opposite. The best production systems aren’t the ones with the most layers. They’re the ones that found the thinnest path to a reliable outcome, the ones who didn’t overcomplicate the recipe.
Cultivating an AI system means understanding that value compounds over time. Your eval suites become more precise with every failure you capture, your context injection sharpens as data pipelines mature, and the model’s native intelligence stabilizes not because you added an orchestration framework, but because you fed the starter better ingredients.
It’s time to stop baking the cake and instead cultivate the starter.
Learn More
Autonomize AI Launches Version 3 of the Autonomize Intelligence Platform
Citations
- Mismanaged Genius Hypothesis: https://alexzhang13.github.io/blog/2026/mgh/
- ZenML — LLMOps in Production: 457 Case Studies of What Actually Works; 287 More Case Studies; and What 1,200 Production Deployments Reveal About LLMOps in 2025.
- Microsoft ISE Team — Earning Agentic (and LangChain) Complexity, ISE Developer Blog.
- Sergii Piatakov — Things You’re Overengineering in Your AI Agent (The LLM Already Handles Them), DEV Community, April 2026.
- Simon Willison — Things We Learned About LLMs in 2024, Substack; ongoing coverage at simonwillison.net/tags/evals.
- Anthropic — Introducing the Model Context Protocol, November 2024. Subsequently donated to the Linux Foundation’s Agentic AI Foundation, December 2025.
About the Author
Ganesh Padmanabhan is the CEO and founder of Autonomize AI, where he is building AI-native solutions for healthcare enterprises. With over 20 years of experience across AI, cloud, and enterprise transformation, he focuses on embedding governed intelligence into workflows to improve outcomes and reduce operational friction. A recognized voice in responsible AI and healthcare innovation, Ganesh is a frequent speaker, advisor, and advocate for using technology to tackle humanity’s biggest challenges.
