The Agentic Operating System: Three Architectures, One Structural Shift

In the span of sixty days, three separate companies shipped three distinct products that all do the same fundamental thing: sit between the human and the operating system and take over the work. Not as assistants. Not as copilots. As autonomous agents that plan, execute, and iterate on complex tasks across applications, files, and services. That's not a product trend. That's an architectural layer forming in real time.

Nvidia's NemoClaw, announced at GTC on March 16, wraps the viral OpenClaw agent framework in enterprise-grade sandboxing and deploys across every class of Nvidia hardware with a single command. Perplexity's Computer, launched in February, orchestrates 19 frontier AI models simultaneously to execute workflows that run for hours or months. Anthropic's Cowork, released in January, turns the Claude desktop app into an ambient agent that reorganizes your files, processes your receipts, and drafts your documents, all without writing a line of code.

Three different companies. Three different architectures. The same structural bet: the operating system you've been using for decades is becoming a bootloader. The real work happens one layer up, in what we're calling the Agentic OS. We've been tracking this convergence at INS since we wrote about the agent era arriving and the primitive advantage. What follows is our assessment of what the Agentic OS layer looks like now that it's here, and what it means for organizations like ours.

What an Agentic OS Actually Is

An operating system has always done the same three things: manage hardware resources, enforce security boundaries, and provide an interface between the user and the machine. Windows, macOS, and Linux do this at the level of processes, files, and peripherals. The Agentic OS does it at the level of agents, models, and workflows.

The analogy is precise, not metaphorical. Consider what these new platforms actually manage:

• Agent lifecycle: Creating, scheduling, monitoring, and terminating autonomous processes that execute multi-step tasks
• Model routing: Deciding which AI model handles which subtask, based on capability, cost, latency, and privacy requirements
• Security and sandboxing: Constraining what agents can access, what data can leave the environment, and what actions require human approval
• Resource allocation: Managing compute (local GPU vs. cloud), memory (context windows), and input/output (file access, API calls, browser control)
• Policy enforcement: Applying organizational rules about what agents are permitted to do, who can deploy them, and how their actions are audited

That's not a feature list. That's an operating system specification. The only difference is that the "processes" are intelligent, the "memory" is a context window, and the "peripherals" are AI models from different providers.

Why Now

This convergence isn't accidental. We've been watching three conditions mature simultaneously, and they all crossed critical thresholds in late 2025 and early 2026:

Models became reliably capable. Claude, GPT, and Gemini crossed the threshold where they can execute multi-step tasks with enough accuracy that autonomous operation becomes practical, not theoretical. The failure rate dropped from "needs human review at every step" to "needs human review at the outcome." That's the difference between a copilot and an operating system.

Agent frameworks went mainstream. OpenClaw launched in January 2026 and accumulated 247,000 GitHub stars and 145,000 Discord members in weeks, making it the fastest-growing open-source project in history. Jensen Huang, not known for understatement, called it "probably the single most important release of software, probably ever." Millions of users discovered that a local AI agent could browse the web, manage files, triage email, and chain tasks together without a human in the loop. The demand signal was unambiguous.

Enterprise governance caught up. The security and compliance infrastructure that enterprises require, including sandboxing, audit trails, policy enforcement, and data residency controls, didn't exist for agent workloads until NemoClaw and similar platforms shipped it. The gap between "technically possible" and "enterprise-deployable" closed in a matter of weeks.

Gartner's numbers confirm the acceleration: 40% of enterprise applications will include task-specific AI agents by the end of 2026, up from less than 5% in 2025. The research firm calls it one of the fastest transformations in enterprise technology since the adoption of the public cloud, and warns that CIOs have "three to six months to define their AI agent strategies or risk ceding ground." The global AI agents market reached roughly $7.8 billion in 2025 and is projected to exceed $10.9 billion in 2026. Gartner's longer-range projection: agentic AI could drive 30% of enterprise application software revenue by 2035, surpassing $450 billion.

The Three Architectures

What makes this moment structurally interesting is that NemoClaw, Perplexity Computer, and Anthropic Cowork represent three fundamentally different bets on what the Agentic OS layer looks like. They agree that the layer exists. They disagree on where it runs, who controls it, and how it relates to the models underneath.

What This Means for Enterprise IT

For CIOs, IT leaders, and organizations like ours, the emergence of the Agentic OS layer creates four immediate questions that current infrastructure planning doesn't address. We've been working through these ourselves, and we suspect you're facing the same ones.

Infrastructure

Agent workloads have fundamentally different resource profiles than traditional applications. They consume GPU cycles for inference, require large context windows (memory), make unpredictable numbers of API calls (input/output), and can run for extended periods. Capacity planning models built for web servers and databases don't account for agents that autonomously spawn sub-agents, each routing to different model providers with different latency and cost characteristics.

The infrastructure decision is also a control decision. NemoClaw runs on hardware you own. Perplexity Computer runs in their cloud. Cowork runs on employee desktops. Each choice has different implications for data residency, network architecture, and capacity management. But the encouraging reality is that these aren't exclusive choices. Just as we all run both on-prem and cloud workloads today, most organizations will deploy multiple agent architectures matched to different use cases. The infrastructure skills you already have transfer directly. The constraint shifts from learning a new discipline to applying existing expertise in a new context.

Security and Governance

Autonomous agents represent a new class of security principal. They aren't users and they aren't applications in the traditional sense. They're processes that make decisions, access data, and take actions based on goals rather than explicit instructions. The security questions are real: What data can an agent access? Can it send information outside the network? What happens when an agent's action has unintended consequences? Who is accountable?

But here's the encouraging part: these questions are being answered faster than any previous enterprise technology transition. NemoClaw shipped process-level sandboxing on day one. Cowork's folder-level permissions give users granular control from the first interaction. Perplexity Computer's cloud architecture enforces access boundaries by design. OWASP published its Agentic Security Initiative Top 10, covering risks from goal hijacking to rogue agents. The Cloud Security Alliance released an Agentic Trust Framework applying zero-trust principles to AI agents. Microsoft open-sourced an Agent Governance Toolkit covering all 10 OWASP agentic risks. And Anthropic, OpenAI, and Block co-founded the Agentic AI Foundation under the Linux Foundation, with AWS, Google, Microsoft, Bloomberg, and Cloudflare as platinum members. The governance infrastructure isn't theoretical. It's shipping alongside the agents, and the institutional standards bodies are already organizing around it.

Procurement

As we discussed in After NemoClaw, the procurement process itself is being transformed by agents. When a NemoClaw-powered procurement agent evaluates vendors, it browses websites, extracts specifications, and compiles comparison reports autonomously. The vendors whose data is structured for machine consumption get recommended. The vendors whose data is buried in PDFs and marketing copy get skipped.

This creates a compounding opportunity: every investment you make in structuring your own data for agent consumption pays dividends twice. Once when your procurement agents evaluate vendors more effectively. And again when your customers' agents evaluate you more favorably. The organizations that move first on both sides of this equation build an advantage that compounds with every interaction.

Workforce

Here's where the abundance framing matters most. The Agentic OS doesn't eliminate the need for human expertise. It amplifies it. Cowork doesn't make administrative assistants unnecessary. It gives every knowledge worker the capabilities that previously required an administrative assistant. NemoClaw doesn't make network engineers irrelevant. It gives network engineering teams the capacity to manage more complex deployments with the same headcount.

As we explored in The Great Convergence, the shift is from doing to directing. The Agentic OS accelerates that shift by providing the runtime that makes directing agents as natural as launching an application. Without exception, the organizations we see leaning in with genuine curiosity discover capabilities they didn't know they had. Domain expertise becomes worth more in this model, not less, because the humans who understand the work are the ones best positioned to direct the agents that execute it.

The Five Questions for Your Organization

Based on the architectural patterns emerging across these three platforms, here are the questions every organization should be working through this quarter:

1. Where does your sensitive data live, and which agent architecture respects those boundaries? If your compliance requirements prohibit sending operational data to third-party clouds, NemoClaw's local-first model is your starting point. If your data is already in cloud services, Perplexity Computer's orchestration layer may be more natural.
2. What is your team's technical baseline? Cowork requires zero technical setup. NemoClaw requires infrastructure management. Perplexity Computer requires workflow design. Match the platform to the team, not the other way around.
3. Which workflows would benefit most from autonomous execution? Start with workflows that are repetitive, well-defined, and currently bottlenecked by human availability rather than human judgment. Document processing, vendor evaluation, report generation, and data reconciliation are strong candidates.
4. What is your agent governance policy? Before deploying any agent platform, define: What data can agents access? What actions require human approval? How are agent actions logged and audited? Who is accountable for agent-initiated outcomes?
5. How agent-readable is your own digital presence? As your customers and partners deploy agents, those agents will evaluate your website, your documentation, and your product data. Is your digital infrastructure ready to be read by machines, not just humans?

The Competitive Landscape Beyond the Big Three

NemoClaw, Perplexity Computer, and Cowork are the most architecturally distinct examples, but they aren't operating in a vacuum. The broader competitive landscape confirms that every major technology company is making the same structural bet:

• Microsoft Copilot Cowork (March 2026), built in collaboration with Anthropic using Claude as the reasoning engine, not OpenAI, handles long-running multi-step tasks across Microsoft 365. Agent 365 launches at $15/user/month in May 2026. The choice of Anthropic over OpenAI for their flagship agent product is itself a signal about multi-model strategy.
• Salesforce Agentforce has reached 29,000+ cumulative deals, $800 million ARR (up 169% year-over-year), with 18,500 enterprise customers running 3+ billion automated workflows monthly. Their Autonomous Service Agent handled 2.8 million support requests in the past year.
• OpenAI Operator provides browser-based agent capabilities for task execution on behalf of users, interacting with any website without pre-programmed instructions
• Google Project Mariner extends Gemini into browser-controlling agent territory with up to 10 parallel task streams and a "Teach and Repeat" feature that learns demonstrated workflows
• HP CosmOS is an operating system built entirely around AI agents rather than traditional applications, using an "AI Bus" orchestration layer where specialized agents handle every function. This is the most literal interpretation of the Agentic OS concept: not a layer on top of the OS, but the OS itself.

The convergence is unmistakable. Every platform is building toward the same layer. The differentiation is in architecture (local vs. cloud vs. ambient), model strategy (single-provider vs. multi-model), and target user (developer vs. IT admin vs. knowledge worker).

The OS Vendors' Response

One of the most interesting questions in this shift: how are Microsoft, Apple, and Google repositioning as the value migrates from the OS layer to the agent layer? The answer reveals how much opportunity this transition creates, even for incumbents.

Each is responding differently. Microsoft is integrating Copilot into Windows at every level, from system-wide AI assistants to Copilot+ hardware with dedicated neural processing units. Notably, they chose Anthropic's Claude over their own OpenAI partnership for Copilot Cowork, signaling that even Microsoft sees multi-model orchestration as the path forward. Apple is overhauling Siri in spring 2026 with conversational multi-step task capabilities, adopting Google's Gemini as its underlying LLM, and moving toward what they call "Full Agency," where Siri proactively manages the user's digital life. Google is merging ChromeOS and Android into "Aluminium OS," arriving fall 2026 for premium laptops, built with AI at the core, while Project Mariner handles web agent capabilities.

There's a deeper dynamic worth noting. When Anthropic built Cowork in ten days, they demonstrated that the Agentic OS layer can be constructed by a model provider without any cooperation from the underlying OS vendor. Cowork runs in user space, accesses files through standard permissions, and connects to external services through MCP. This means the barrier to building agent infrastructure is lower than any previous platform shift. For enterprises, that's an advantage: you aren't locked into a single vendor's agent platform the way you were locked into specific OS platforms. The competitive pressure among agent providers works in the buyer's favor.

That's the structural shift for OS vendors. The value is migrating upward, from the kernel to the agent layer. But this isn't a zero-sum outcome. The companies that integrate agent capabilities directly into their platforms, as Microsoft is doing with Copilot+ and Apple with Apple Intelligence, will create new value at the intersection of hardware, OS, and agents. The opportunity expands for every player in the stack. The constraint shifts from "who owns the file system" to "who orchestrates the most useful agents," and that's a larger addressable market, not a smaller one.

What This Means for INS

The Path Forward

We are in the early weeks of the Agentic OS era. The platforms are shipping. The architectures are diverging. The enterprise governance frameworks are forming. But the direction is unmistakable: a new layer of the computing stack is consolidating between the human and the machine, and it will determine how enterprise work gets done for the next decade.

The encouraging reality is that engaging with this shift doesn't require choosing a single architecture or betting on a single vendor. It requires developing the organizational skills, the primitive fluency, the agent governance policies, and the machine-readable data infrastructure, that make your teams and your digital presence ready for whichever architecture your customers and partners adopt.

As we discussed in The New Default, the question is no longer whether to engage with AI. The Agentic OS makes the question even more specific: are you building the runtime that lets agents work on your behalf, or are you waiting while your competitors build theirs?

Anthropic built Cowork in ten days. Nvidia shipped NemoClaw with a single-command install. Perplexity Computer lets you describe a month-long workflow in a single prompt. The barriers to entry are not technical. They are organizational. The teams that start now, that pick one workflow, deploy one agent, learn one governance lesson, will find that the next deployment is faster, the next policy is clearer, and the next integration compounds on everything that came before.