Every enterprise building an agentic system eventually runs into the same question: should we build this or buy it?
It's the wrong question — or at least, it's incomplete. An agentic system isn't one thing. It's a stack, and each layer of that stack is its own build-or-buy decision, with its own market of open source projects and SaaS vendors competing for it. Treating the stack as a single decision is how organizations end up with a bought harness bolted to a built retrieval layer nobody evaluates, or a beautifully instrumented system whose auth model was an afterthought.
There are more layers than the five below, but these are the ones every organization has to think through independently.
1. UI / Harness
This is where your people actually meet the system — the surfaces through which they interact with agents, skills, MCPs, and tools. Chat interfaces, IDE integrations, internal copilots, agentic desktop apps.
The harness layer moves fast, because it's the layer most tightly coupled to model capability. Scaffolding built to compensate for a weaker model becomes a constraint when the model improves — we've watched vendors strip out large portions of their own harness logic as models got better. That churn rate should factor into your decision here: anything you build at this layer, you should expect to rebuild or delete.
2. Authentication
Who — and which agents — can access which parts of the system. Certain users get certain MCPs. Certain agents get certain skills and tools. Scoped credentials, least-privilege for agents, knowing when an agent should stop.
This layer is easy to defer and expensive to retrofit. The moment agents can take actions instead of just answering questions, identity and permissions stop being an IT checkbox and become the thing standing between you and an agent with production credentials it shouldn't have.
3. Agents & Tools
The MCPs, skills, agents, and tools that are actually available to users — via their harness — to enable workflows. This is the layer people usually mean when they say "we're building agents."
It's also the layer where sprawl happens fastest. Without governance, skills and tools duplicate, drift, and degrade. The catalog of what your agents can do is an asset that needs an owner, not a folder that accumulates.
4. Context Graph
The organization of your internal data for agentic search: the documents, databases, and other data your organization produces, continuously feeding and updating a graph your agents can actually reason over. This layer needs to support agentic search and embeddings — it's what makes the whole system relevant to your business instead of generically capable.
This is the layer I'd argue enterprises should be most reluctant to fully outsource. Your context graph is your organization's language — its entities, relationships, and definitions. Vendors can supply the substrate, but the ontology is yours, and whoever owns it holds the deepest leverage in the system.
5. Observability & Evals
How you know things are working — or not — and how you have a disciplined approach to improving them. Traces, eval criteria, curated datasets, regression detection.
This is what separates teams that know their agents improved from teams that are guessing. You can't tail -f an agent. Without this layer, every change to a prompt, a tool, or a model version is a change you're shipping on vibes.
Five layers, five markets
Here's what makes this genuinely a five-way decision rather than one: every single layer above has real competition in the AI startup space right now. Credible open source options exist at every layer. High-quality SaaS options exist at every layer. There is no layer where the market has decided for you.
Which means the useful question isn't "build or buy?" It's: for each layer, independently — build or buy?
How we think about the split
A rough heuristic we use with clients at AgentGraph:
Buy (or adopt) where the market is commoditizing fast. The harness layer is the clearest case — the pace of model improvement keeps invalidating custom scaffolding, and the vendors absorbing that churn are doing it across thousands of customers instead of one.
Own what encodes your organization. The context graph and your eval criteria are the two layers that are made of you — your data, your definitions of correct. You can buy tooling for both, but the ontology and the eval sets themselves are assets you should hold, version, and maintain like source code.
Decide auth early, whichever way you go. It's the layer where "we'll figure it out later" costs the most.
Getting these calls right, layer by layer, is a large part of what it means to become an AI-native organization. Getting them wrong doesn't fail loudly — it fails as a system that technically works and never quite compounds.
AgentGraph designs agentic systems and places forward-deployed engineers with enterprise teams working through exactly these decisions. If you're mapping your own stack, we should talk.