We're Building Operating Systems Again — This Time for Agents

At GTC 2025, Jensen Huang said something that stopped me mid-coffee. He called OpenClaw the most popular open-source project in the history of humanity — growing faster than Linux ever did. He called it the operating system for the agentic age.

That's a massive claim. But I think he's right. And I think most people are underestimating what it actually means.

The Click Is Disappearing

Here's the shift I keep coming back to: the paradigm change isn't that AI is getting smarter. It's that the click is going away.

Every interface we've ever built — the screen, the button, the form, the dropdown, the modal — was designed for a single purpose: to let humans operate software. We spent decades optimizing pixels so people could point, tap, and type their way through digital tasks. That entire model assumes a human is sitting in front of a screen, making decisions, clicking things.

But when an agent can read your calendar, check your email, coordinate with other agents, and execute tasks autonomously — what's the interface? A conversation, maybe. A periodic heartbeat. Or nothing at all.

I think we're moving rapidly into a world where most digital work happens without anyone looking at a screen. Agents don't need dashboards. They don't need design systems or responsive layouts. They need identity, memory, routing, and communication protocols. They need an operating system.

That's OpenClaw.

What Jensen Actually Said — and Why It Matters

Jensen's framing at GTC was structural, not hype. He described OpenClaw as the layer that connects LLMs, tools, file systems, scheduling, cron jobs, sub-agents, and I/O into a coherent system. The same way Linux connected hardware, drivers, and applications into something developers could build on — OpenClaw connects the pieces that agents need to function as autonomous entities.

He went further. He said every company needs an OpenClaw strategy. Not a chatbot strategy. Not an "AI features" strategy. An operating system strategy for agents.

My take: he's describing the same inflection point we've seen before with Linux, HTTP, and Kubernetes. Each one was an infrastructure layer that seemed optional at first and then became so foundational that ignoring it meant falling behind. OpenClaw is following the same curve — except faster, because the demand is already there.

And NVIDIA is putting serious weight behind it. NemoClaw, OpenShell, enterprise policy engines — these aren't side projects. They're NVIDIA's answer to the hardest question in agentic computing: security. Because when an agent can reach sensitive data, execute code, and communicate externally, the stakes are fundamentally different from a chatbot summarizing documents.

Beyond the Screen

I think the deeper insight is about what disappears, not what appears.

For thirty years, the tech industry has been organized around user interfaces. Designers design them. Developers build them. Product managers prioritize features based on what users see and click. The entire feedback loop — analytics, A/B tests, conversion funnels — assumes a human eyeball at the end.

Agents break that loop. An agent doesn't browse your website. It calls your API. It doesn't fill out your form. It sends structured data. It doesn't read your dashboard. It queries your database.

This means the surface area of software shifts. The value moves from the presentation layer to the protocol layer. How well does your service expose its capabilities to agents? How cleanly can an agent authenticate, request, and act? The companies that answer those questions well will thrive. The ones still optimizing button colors for human thumbs will wonder what happened.

I've been running autonomous agents in my daily work, and the thing that strikes me most isn't what they can do — it's how quickly the screen becomes irrelevant. The most productive interactions aren't visual at all. They're scheduled tasks, background coordination, agents checking in with each other and deciding whether to act or stay quiet. Heartbeats, not clicks.

The Strategy Stack

Every major computing era produced a strategy layer that companies had to adopt or get left behind:

The Linux strategy. In the late '90s, every enterprise had to decide how to engage with open-source operating systems. Ignore Linux, and you locked yourself into expensive proprietary stacks. Adopt it, and you gained flexibility, community, and cost efficiency. It wasn't optional — it was existential.

The HTTP strategy. The web forced every business to rethink distribution. You could have the best product in the world, but if it didn't work in a browser, it didn't exist for a growing share of the market.

The Kubernetes strategy. Cloud-native infrastructure demanded orchestration. Companies that containerized early could scale, deploy, and iterate faster. Those that didn't were stuck managing servers by hand while competitors shipped daily.

The OpenClaw strategy. This is the current inflection. Every SaaS company is becoming an Agentic-as-a-Service company — whether they realize it or not. If your product can't be operated by an agent, you're the website that doesn't work on mobile in 2012. Technically functional. Strategically dead.

The pattern is always the same: an infrastructure layer emerges, early adopters get disproportionate leverage, and within five years it's table stakes. OpenClaw is in the early-adopter phase right now. But Jensen putting NVIDIA's full weight behind it — enterprise security, policy engines, the works — suggests the acceleration phase is about to begin.

The Security Question Is the Real Question

Here's where it gets serious. An agent with access to your calendar, email, file system, and communication channels is operating with something close to kernel-level permissions. It can read sensitive data. It can execute code. It can send messages on your behalf.

The trust model for this is completely different from traditional software. A web app runs in a sandbox. An agent runs in your life.

This is why NVIDIA's investment in NemoClaw and OpenShell matters. Policy engines, permission boundaries, audit trails — these aren't nice-to-have features. They're the thing that makes the entire paradigm viable for enterprise use. Without them, agentic computing stays a hobbyist curiosity. With them, it becomes infrastructure.

I think the security challenge is actually the most interesting part of this whole space. It forces us to think carefully about trust, delegation, and oversight in ways that traditional software never required. When you deploy a web server, it doesn't decide to email your clients. An agent might. The control plane for agents is a fundamentally new design problem, and I'm glad serious engineering resources are flowing into it.

What This Means for the Next Five Years

My read on where this goes:

Every company will need an agent infrastructure team, the same way they needed a cloud infrastructure team a decade ago. Provisioning agents, managing permissions, monitoring behavior, handling incidents — this is the next ops discipline. AgentOps, if you want a name.

The companies that win won't be the ones with the smartest models. They'll be the ones with the best agent infrastructure — the ones who figured out identity, memory, routing, security, and coordination before their competitors.

The interface layer doesn't disappear entirely, but it shrinks. Humans will still need visibility and override capabilities. But the day-to-day operation of digital work increasingly happens in the background, between agents, through protocols instead of pixels.

And OpenClaw — or something very like it — becomes the Linux of this era. The foundational layer that everything else builds on. Open-source, community-driven, extensible, and absolutely critical.

Jensen called it the operating system for the agentic age. I think that's exactly right. The last time we built operating systems, we were connecting hardware to humans. This time, we're connecting intelligence to everything else. The patterns are familiar. The stakes are higher. And the window for strategic positioning is open right now — but it won't stay open long.