Buy
Use it like a utility. Switch whenever you want.
lead → Models
A working model · one CTO to another · 2026
The Composable Intelligence Stack
I'm a CTO, and this is how I think about building enterprise AI, layer by layer, and how I'd buy or build each piece. It isn't a vendor pitch or a maturity chart. It's just what holds up once you have to run the thing for real. Take what's useful and argue with the rest.
Most people still picture enterprise AI as one model sitting on a data lake. Run it for real and it's bigger than that. It's a full system working together: a fleet of models behind one control plane, grounded in your own data and the meaning behind it, plugged carefully into the tools and systems that run your business, and watched constantly for quality, cost, and risk.
The strategy under it is one line I keep repeating: buy the commodity, build the differentiator. Buy the models. Build your semantics and your product experience. The connective stuff in between, you configure, extend, or compose.
1 in 5
AI investments that show measurable ROI today. That gap is exactly what a stack like this is meant to close.
Gartner, 2026
+80% / -60%
how much more accurate and how much cheaper you can get by 2027 if you take your semantic layer seriously
Gartner, 2026
>40%
share of agentic AI projects expected to get canceled by the end of 2027, mostly over cost, unclear value, or weak controls
Gartner, 2025
The stack · tap any block
Seven layers, four planes
I read it two ways. Top to bottom is how a request actually moves: the experience layer calls the control plane, which picks a model, which reasons over context, acts through the workflow layer, and reaches your data and tools. Bottom to top is the order I'd build it in, because every layer is only as good as the one underneath it.
Sourcing lens
The five postures from the build-vs-buy framework I use, Buy through Build. Tap one to see where it lands.
Every layer has a posture I lean toward (bright) and a backup (faint). Line up the leads and you get my default: buy the models, build your semantics and experience, configure the data foundation, extend the control plane, compose context and action.
planes that
run through it all
run through it all
Build vs. buy
Buy the commodity, build the differentiator
A diagram tells you what the layers are. The question I actually get from other CTOs is how to source each one. Here's how I think about it: spend your build budget where you're different from everyone else, and rent everything that's turning into a utility.
Models are commoditizing faster than anything else in the stack, so I buy them. My semantics and my product experience are the parts a competitor can't copy, so I build those. Everything connective in between, context, runtime, action, I configure, extend, or compose.
Configure
Adopt a platform, tune it to your shop.
lead → Data
Extend
Take a base, add your own policy.
lead → Control plane
Compose
Wire together the strongest parts you can find.
lead → Context, Action
Build
Own it outright. It's the moat.
lead → Semantics, Experience
In real life almost nothing is one posture. Each layer has a lead and a backup. The lens up top shows both, bright for the lead and faint for the backup. Tap through them and the point jumps out: Extend shows up almost everywhere, the connective tissue, while Build sits in just two places. Broad rental, narrow ownership. That's the whole game.
What I believe
The rules I keep coming back to
Seven things I'd stand behind no matter which vendors win. This is the part I'd actually want to argue about with you, because the tools underneath are all going to change.
01
Composable, not monolithic
Every layer swaps out behind a stable seam. The model churns fastest, so make it the easiest thing to replace.
02
Govern meaning, not just data
Accuracy lives in the semantic layer. It's where raw data turns into meaning a model can trust. Point one at ungoverned data and all you get is wrong answers faster.
03
No single model, no single provider
Route for fit, fail over for resilience. Just test the fallback, because a different model is never a clean drop-in.
04
Action is its own layer
What hurts you isn't a wrong answer, it's a wrong action in a system of record. Approvals, idempotency, and rollback are architecture, not cleanup.
05
Standardize the seams
MCP and A2A matter, but they aren't the only seams. Your shop still runs on APIs, event buses, and workflow engines. Standard seams are what keep everything else swappable.
06
Make memory forgettable
Persistent memory only earns its place if it's permissioned, inspectable, and easy to delete. TTL, consent, and scope from day one.
07
Govern and evaluate as you go
Security, governance, observability, and evals run through every layer. None of them is something you bolt on the week before launch.
Where I'd start
If I were standing this up today
Nobody builds the whole thing at once. Here's the order I'd go in.
Crawl
Stop the bleeding
- One gateway in front of two providers, with failover you've actually tested.
- A semantic layer over your ten most-used metrics.
- Read-only access to two or three systems of record. Nothing that can write yet.
Walk
Ground it and gate it
- Routing by cost and quality, not just by model name.
- GraphRAG and a governed memory layer on your highest-value domain.
- An action layer with approvals and idempotency before anything writes.
- Evals and cost tracking wired into the control plane.
Run
Run it for real
- A real ontology on your core domains.
- Multi-agent workflows, with a human in the loop on anything risky.
- Governance mapped to NIST and the EU AI Act, evals as release gates.
Where the numbers come from ▾
Gartner, lack of semantics causes inaccurate AI agents (the 80% / 60% by 2027 numbers)
Gartner, over 40% of agentic AI projects canceled by end of 2027
OWASP, Top 10 for Agentic Applications 2026 (the ASI Top 10)
OWASP, LLM06 Excessive Agency and the least-agency principle
Context & Chaos, semantic layer (lookup) vs. ontology (reasoning)
Atlan, ontology vs. semantic layer; grounding cuts hallucination
Gartner D&A Summit 2026, ~60% of AI spend on foundations
Linux Foundation, the Agentic AI Foundation (MCP and A2A)
CIO, MCP moves systems from exposing data to acting on it
Contabo, the AI gateway and control-plane landscape
TrueFoundry, failover patterns and the fidelity tradeoff
InfoWorld, cloud LLMs and enterprise resilience
AgenticWire, memory architectures (Mem0, Zep, Letta)
Atlan, memory frameworks still lack enterprise governance
NIST, AI Risk Management Framework
Cloudflare, AI Gateway (caching, rate limiting, fallback)