Buy the orchestration layer of your agentic operating system if your agents mostly drive SaaS apps whose code you do not own — Make or ServiceNow will get you further in a quarter than a bespoke scheduler will. Build on LangGraph when the agents live inside your own codebase, your state model is unusual, or compliance requires auditable deterministic steps you can read in a diff. The one option that loses for almost everybody is writing coordination glue from scratch: the failures at this stage are architecture failures, not model failures.
TL;DR
- Buy when the work crosses tools you do not control: Make for mid-market breadth, ServiceNow when the work already lives on the Now Platform.
- Build on LangGraph when agents run inside your application, need durable long-running state, or must interleave hand-written deterministic steps with model-driven ones.
- Never build the router, retry logic, and audit trail from nothing. That is the part vendors have already solved.
- Most teams already have tool access and agents. The missing pieces are orchestration, governance, and observability.
- Model choice is no longer the hard part, which is exactly why the OS layer is the decision that matters.
- Last verified: 21 September 2026.
What is an agentic operating system, and why is it not a product?
An agentic operating system is a coordination layer rather than a thing you install. It gives several AI agents shared memory, tool access, decision logic, and human oversight so they can finish multi-step work across real systems instead of producing one clever reply and stopping. The Make guide to the pattern maps five classic OS jobs onto agents: resource management becomes API quota and token budgets, process scheduling becomes triggers and step ordering, shared memory spans sessions and agents, standard I/O becomes the contract between agents and tools, and permissions become who may touch what.
In practice a credible stack has six layers: connections and tool access (MCP, A2A, REST and webhooks, native connectors); memory in ephemeral, session and shared tiers; the agents themselves, each with an identity, a goal, a toolset and its own model; orchestration and routing, including deterministic branches, probabilistic handoffs, human-in-the-loop gates and error escalation; governance, guardrails and audit; and observability. Our own walkthrough of that structure is in the five-layer build guide.
Where do agent projects actually stall?
Layers 1 and 3 are usually already in place. Teams have connectors, and they have agents. Layers 4 to 6 — orchestration, governance, observability — are missing or improvised, and that is where pilots go quiet.
The external evidence points the same way. An MIT NANDA study reported that 95% of enterprise generative AI pilots showed little to no measurable P&L impact, with the cause traced to a learning and integration gap rather than model quality. Gartner separately projects that over 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value and inadequate risk controls. Both findings describe a plumbing problem.
Meanwhile the demand side keeps rising: Gartner forecasts that 40% of enterprise applications will feature task-specific AI agents by the end of 2026, up from under 5% in 2025. More agents in more apps makes an unmanaged coordination layer more expensive every quarter, not less.
When should you buy: Make or ServiceNow?
Buy when the agents' real job is operating software you did not write.
Make supplies the layers visually. Scenario Builder is the orchestration surface, the Router module gives you deterministic branching you can see, Make AI Agents let you pick a different model per agent across OpenAI, Anthropic and Gemini, and Make Grid covers observability. Its MCP support runs both ways: scenarios can be exposed as tools to external agents, and agents inside Make can call external MCP tools. That bidirectionality is the practical reason it survives contact with a messy SaaS estate.
ServiceNow is the choice when the work already sits on the Now Platform. It ships AI Agent Orchestrator for task delegation, policy enforcement, workflow context and error re-routing, with AI Agent Fabric as the communication layer. At Knowledge 2026 in May, Agent Fabric gained MCP and A2A support, and a generally available MCP Server began running actions through Control Tower for identity, permissions and audit. If your auditors already trust that platform, you inherit the trust.
At the top end, buying tends to mean consolidating. EY, with more than 300,000 professionals, folded fragmented generative AI work into a single agentic platform co-engineered with Microsoft and NVIDIA because multistep autonomy, data lineage, consent governance and interoperability could not live inside isolated point builds.
When should you build on LangGraph?
Build when the agent is part of your product, not a tenant in someone else's. LangGraph describes itself as a low-level orchestration framework and runtime for long-running, stateful agents, with durable execution, streaming, human-in-the-loop and persistence, and it lets you mix hand-coded deterministic steps with model-driven steps in one graph. That mixing is the feature most compliance teams end up wanting.
Be clear about what you are taking on. LangGraph is orchestration only: you supply the models, tools and integrations. Installation is a pip install langgraph away, but the integration glue, memory store, evaluation harness and tracing are yours, with LangSmith as the commercial observability option. Compare that against buy-side cost drivers — agent reasoning calls, tool executions and memory storage, where spend caps and routing efficiency matter more than which plan tier you sit on.
Embedded vendor agents (Slack's, Fiserv's agentOS, ServiceNow's own) are a third path: quick to switch on, narrow in cross-system reach. Useful inside one tool, insufficient as the OS.
Why is model choice no longer the deciding factor?
Because the models have converged on constraint-following. Across three trials each on an identical seven-constraint article-planning task, Gemini 3.8 Flash (High) and Claude Opus 4.6 (Thinking) both scored 17 of 17 on machine-checked constraint adherence. Median wall time was 23 seconds for Gemini against 67 seconds for Opus. Computed live from our own measured stores, n=6 runs (3 trials × 2 models), measured 21 September 2026.
Routing between models is now a solved sub-problem — pick on latency and price per step. The unsolved part is the layer above: who calls what, in what order, with which memory, under whose permission, and with what record afterwards. For the conceptual split between an agent and the orchestration around it, see agentic AI versus AI agents.
How do you decide this week?
Run a six-layer audit and score each layer red, amber or green.
- Connections — list every system your agents touch and how (MCP, native connector, raw REST). Any undocumented integration is red.
- Memory — name the store for ephemeral, session and shared context. If shared context is a spreadsheet, it is red.
- Agents — one identity, one goal and one toolset per agent, with its model named.
- Orchestration — can you draw the routing graph from memory, including the error path? Governance check: who approves a destructive action, and where is that logged? Observability check: can you replay yesterday's failed run?
If layers 1 to 3 are green and 4 to 6 are amber or red, buy. If layer 4 needs behaviour a visual builder cannot express, build on LangGraph and buy observability. Our practical setup notes live in the 2026 agent OS guide, the shared-memory publishing workflow, and a no-cost starting stack.
FAQ
Q: Is an agentic operating system a real operating system?
A: No. It is a coordination layer above your existing systems that borrows five OS responsibilities — resource limits, scheduling, shared memory, standard I/O and permissions — and applies them to agents.
Q: Can I use Make and LangGraph together?
A: Yes, and it is a common split. LangGraph handles stateful reasoning inside your codebase, while Make owns the SaaS-facing steps; Make's MCP server and client let each side call the other as a tool.
Q: What does buying an agentic OS actually cost?
A: The drivers are agent reasoning calls, tool executions and memory storage rather than the plan tier. Set spend caps and reduce unnecessary reasoning steps before you negotiate a bigger plan.
Q: Why do so many agentic projects get cancelled?
A: Gartner attributes the projected cancellations to escalating costs, unclear business value and inadequate risk controls — all governance and orchestration gaps, not model failures.
Q: Should a small team build anything at all?
A: Build agents and prompts, buy orchestration. Writing your own router, retry logic and audit trail is the most expensive way to learn what a Router module already does.
Q: Does MCP make vendor choice reversible?
A: Partly. MCP and A2A standardise how agents reach tools and each other, so connections port more easily. Your orchestration graph, memory schema and audit history usually do not.
Corrections log: none. Last verified 21 September 2026.
Top comments (0)