In brief
- Agents are moving from pilots to production. McKinsey's 2026 survey found 40% of large organisations scaling AI agents, up from 27% a year earlier. Gartner expects 40% of enterprise applications to include task-specific agents by the end of 2026.
- Scaling breaks on fragmentation: agents built per team, per vendor and per application, each with its own controls. The answer leading enterprises have reached is one agentic operating system rather than many agent projects.
- EY's published build of its own platform names three foundations: unified intelligence, unified orchestration and workflow, and a unified data and trust foundation. We add a fourth that turns them into safe action: a Governed Runtime between agents and systems of record.
- This guide gives the reference architecture, the request flow, the operating model and a four-stage rollout, and shows where ElixirClaw provides each piece so you do not have to build the whole stack yourself.
Why do enterprise AI agents stall between pilot and scale?
Not because the models are weak. Because every new agent brings its own runtime, its own integrations and its own controls.
Adoption is real. In McKinsey's 2026 State of AI survey, 40% of respondents from organisations with more than $1 billion in revenue report scaling AI agents, up from 27% the year before. Gartner predicts that 40% of enterprise applications will include task-specific AI agents by the end of 2026, up from less than 5% in 2025.
That second number is the problem as much as the opportunity. If agents arrive inside every application, a large enterprise will soon run hundreds of them, from dozens of vendors, each governed by its own console. Gartner also expects over 40% of agentic AI projects to be cancelled by the end of 2027, citing costs, unclear value and inadequate risk controls.
Our view: the cancellations and the proliferation have the same root. Agents are being added as projects. They need to be run as a platform.
What does an enterprise-scale agentic AI operating system need?
Three foundations that the best-documented enterprise build names, plus the execution layer that makes them safe to use.
EY has published how it built its own platform for this. Its case study, How EY built an enterprise-scale agentic AI operating system, describes the risk it was avoiding: isolated AI efforts, duplicated investment and inconsistent governance. Its answer was one agentic platform, co-engineered with Microsoft and NVIDIA, built on three foundations. In summary:
- Unified intelligence. One way to access, tune, govern and deploy models and agentic reasoning: a model catalogue, tuning pipelines, guardrails, and planning and tool-use frameworks.
- Unified orchestration and workflow. End-to-end autonomous workflows across the technology estate, with agents surfacing inside everyday tools such as email, documents and meetings, and with lifecycle management, identity, security and multi-agent coordination.
- Unified data and trust. Governed, permissioned, lineage-rich data, with governance, Responsible AI frameworks and auditability across the stack.
In a TechTarget interview, EY's Julie Teigland put the lesson in one line: "AI really only scales when all three come together: intelligence, data and governance." She also said EY developed more than 50,000 agents over nine months on the platform.
We agree with the three foundations. We add a fourth, because it is where most enterprises' risk actually sits:
- Governed execution. A runtime that checks policy, applies the agent's autonomy level, asks for human approval where required and records the decision before any action reaches a system of record. Without it, intelligence, orchestration and data are well organised, but nothing stops a wrong action in SAP or ServiceNow.
Most enterprises cannot assemble a platform the way a global firm with deep alliance partnerships can. The practical question for a CIO is how to get all four foundations without building every layer yourself.
What does the reference architecture look like?
Eight layers between the people and agents that make requests and the systems where work happens.

ElixirClaw, our Agentic OS, implements this as eight layers. Here is how they map to the four foundations:
| Foundation | What it has to do | ElixirClaw layers |
|---|---|---|
| Unified intelligence | Turn goals into plans; give agents memory and reasoning; manage prompts and skills like code | Intent engine, agent runtime, skill bank, prompt management |
| Unified orchestration and workflow | Coordinate many agents; run end-to-end workflows across enterprise systems | Agent mesh, execution fabric, connector blueprints, MCP, REST and CLI tools |
| Unified data and trust | Give agents permissioned enterprise context; keep evidence of what they did | Context layer, observability and AgentOps |
| Governed execution | Check every action against policy, autonomy level and approval limits before it runs | Governance engine in the Governed Runtime |
Two design choices matter more than the layer count. First, the runtime governs agents you build and agents you buy, so the vendor agents arriving inside your applications come under the same rules as your own. Second, it deploys where your data rules require: managed cloud, a customer-managed VPC or hybrid on AWS, Azure or GCP, or on-premises and air-gapped, as covered on the security and deployment page.
How does one agent action run through the system?
Every action takes the same path, and every path leaves a trace, including the actions that were stopped.

- Signal or request. A person, a system event or another agent asks for an outcome.
- Intent engine. The goal becomes an execution plan.
- Context and skills. The runtime pulls the enterprise state the plan needs and selects versioned skills from the skill bank.
- Governance engine. Each proposed action is checked against policy, approval limits and the agent's autonomy level: L1 Read, L2 Suggest, L3 Execute within guardrails, or L4 Autonomous within approved boundaries.
- Decision. The action runs, goes to a named approver, or is blocked or modified.
- Execution and trace. The execution fabric acts in the target system, and AgentOps records the plan, the policy result, the approver and the outcome.
The order is the point. Governance happens before execution, not in a report afterwards. The Governed Runtime explainer covers each stage in depth.
What operating model does it need?
A small platform team, named owners in each business domain, and risk and audit involved from day one.
Technology is the easier half. The operating model decides whether the platform scales. Four roles cover most of it:
- Platform team (AgentOps). Runs the Agentic OS: connectors, skills, deployment, observability and cost. It owns the platform, not the business outcomes.
- Agent owners in each domain. Finance, HR, IT and operations each name an owner for every agent, who is accountable for what it does and for its autonomy level.
- Approvers. Named people who decide on consequential actions within the limits policy sets. Approval should be fast, which means the right context is attached to every request.
- Risk, compliance and audit. They write the policies with the domains and read the evidence. Bringing them in at the start is what lets agents move up autonomy levels later.
Our view: autonomy should be earned, not granted. An agent starts at L1 or L2, and moves to L3 when its record in the trace shows it is ready, with the owner and risk agreeing.
How do you roll it out in four stages?
- Stage 1: one consequential workflow at L1 to L2. Pick something real and bounded, such as supplier onboarding, an access request or an invoice exception. Connect the systems, write the policy, and let the agent read and suggest while people decide.
- Stage 2: L3 with approvals in one function. Let the agent act within guardrails and route consequential actions to approvers. Add more workflows in the same function, reusing skills.
- Stage 3: shared skills and all agents on one runtime. Extend to other functions. Bring vendor and SaaS agents under the same governance, and start reusing skills across domains rather than rebuilding them.
- Stage 4: L4 on approved workflows. Where the trace shows consistent results, allow autonomous execution within approved boundaries, with exceptions escalated.
ElixirClaw's Digital Workers, such as Agent SOC, Agent GRC and Agent FinOps, give you a starting point for Stage 1, and the blueprints for SAP, ServiceNow, Workday, Oracle Fusion, Microsoft Dynamics 365 and Infor shorten the connection work.
Which metrics show it is working?
Measure decisions and actions, not only adoption.
- Decision latency: the time from a signal arriving to the right action being taken.
- Autonomy mix: the share of actions at L1, L2, L3 and L4, and how it moves over time.
- Approval turnaround: how long consequential actions wait for a human.
- Blocked and modified rate: how often policy stops or changes a proposed action, and why.
- Skill reuse: how many workflows use each skill, which shows whether you are building a platform or a set of projects.
- Cost per completed workflow: model, platform and human time together.
Should you build it or buy it?
You can build an agentic operating system yourself; EY's case shows what that takes. Expect to build and maintain a runtime with memory, a skill and prompt registry, connectors to every system of record, a policy and approval engine, tamper-resistant tracing and a deployment model for each environment, and to keep all of it current as models change.
Buying makes sense when time to production, consistent governance across vendor agents, and deployment inside your own boundary matter more than owning every layer. ElixirClaw is built for that case. Whichever route you take, the 10-question rubric in our governance buyer's guide is a useful test, and the compliance evidence map shows what your auditors will ask of it.
Frequently asked questions
Q: What is an enterprise agentic AI operating system?
A: It is a single platform that runs, coordinates and governs AI agents across an enterprise: it turns goals into plans, gives agents context and skills, executes actions in enterprise systems, and checks and records every action against policy.
Q: How is an Agentic OS different from an agent framework?
A: A framework helps developers build agents. An Agentic OS runs them in production: it adds persistent runtime, connectors to systems of record, policy and autonomy controls, human approval and execution traces, for agents you build and agents you buy.
Q: What are the foundations of an enterprise-scale agentic AI platform?
A: Unified intelligence, unified orchestration and workflow, and a unified data and trust foundation, plus governed execution: a runtime that checks policy and autonomy before any action reaches a system of record.
Q: Where should an enterprise start with agentic AI at scale?
A: Start with one consequential, bounded workflow at a low autonomy level, with the policy written first and risk involved from the start, then reuse its skills and controls for the next workflows.
Q: Can ElixirClaw govern agents from other vendors?
A: Yes. The Governed Runtime sits between agents and enterprise systems, so it applies the same policy, approval and tracing to agents you build and agents that come with other platforms.
Design your Agentic OS rollout
Bring one workflow and your target systems. We will map it to the architecture above and show the first stage running on your data.