Software that writes, debugs, deploys, and monitors other software is no longer a demo. NVIDIA just announced NemoClaw and its OpenClaw partnership at GTC 2026. Anthropic's Claude Code is shipping production features daily. OpenAI's Operator browses the web and executes multi-step workflows. Google's Gemini agents coordinate across Workspace. The question isn't whether AI agents will restructure the software industry — it's who captures the value when they do.
The Stack Is Forming
Every technology wave produces a stack, and the stack determines who makes money. Cloud computing gave us IaaS (AWS), PaaS (Heroku), and SaaS (Salesforce). Mobile gave us silicon (Qualcomm), OS (Apple/Google), and apps (everyone else). AI agents are forming their own stack, and it looks like this:
| Layer | Function | Key Players | Moat Strength |
|---|---|---|---|
| Compute | Training & inference hardware | NVIDIA, AMD, custom silicon (Google TPU, Amazon Trainium) | Very high (CUDA lock-in, fab constraints) |
| Foundation Models | The "brain" — reasoning, planning, code generation | Anthropic, OpenAI, Google, Meta, DeepSeek | Declining (open source commoditization) |
| Agent Framework | Orchestration, tool use, memory, planning | LangChain, CrewAI, AutoGen, NVIDIA NemoClaw | Low (fragmented, switching costs minimal) |
| Agent Runtime | Execution environment, sandboxing, state management | Claude Code, OpenAI Operator, Devin, Replit Agent | Medium (UX + model integration) |
| Application | End-user workflows, vertical solutions | Cursor, GitHub Copilot, vertical SaaS + agents | High (workflow lock-in, data gravity) |
The pattern is already clear: the bottom of the stack (compute) and the top (applications) have the strongest moats. The middle layers are being commoditized in real time. This is exactly what happened with cloud and mobile. The framework layer is a knife fight with zero switching costs.
NVIDIA's NemoClaw: The Vertical Integration Play
NVIDIA's GTC 2026 announcement of NemoClaw and the OpenClaw partnership isn't just another framework launch. It's NVIDIA moving up the stack — from selling picks and shovels to owning the mine.
NemoClaw is an agent framework optimized for NVIDIA hardware. Tight integration with TensorRT for inference, NeMo for fine-tuning, and CUDA for everything else. The OpenClaw partnership brings standardized tool interfaces — think of it as USB for AI agents, a common protocol for agents to interact with external services.
Jensen's bet: if the framework layer is going to be commoditized anyway, NVIDIA should own the commodity version that runs best on their hardware. It's the same strategy as CUDA itself — free software that makes NVIDIA GPUs indispensable. NemoClaw doesn't need to be the best framework. It needs to be the one that's fastest on H200s and Blackwell.
Claude Code vs. Operator vs. Devin: The Runtime Wars
The agent runtime layer is where the most interesting competition is happening right now. Three distinct approaches are emerging:
Claude Code (Anthropic): A CLI-native agent that reads your entire codebase, executes multi-step tasks, and maintains context across long sessions. It's opinionated about being a developer tool — no GUI, no hand-holding, just raw capability. The model and the runtime are tightly coupled, which means Claude's reasoning improvements directly translate to better agent performance. This vertical integration is Anthropic's moat.
Operator (OpenAI): A web-browsing agent that can execute multi-step workflows across any website. Log into your email, book a flight, fill out a form, navigate a dashboard. It's model-agnostic in theory but optimized for GPT-4.5 in practice. The bet is that web-scale task automation is a larger market than developer tools.
Devin (Cognition): A fully autonomous software engineer that takes a ticket, writes code, runs tests, deploys, and submits a pull request. It operates in a sandboxed environment with its own browser, terminal, and code editor. The ambition is maximal — replace junior engineers entirely.
Each approach reveals a different theory about where AI agents create the most value. Claude Code bets on augmenting expert developers. Operator bets on automating knowledge work broadly. Devin bets on full autonomy in a narrow domain.
The Middleware Question
Between the foundation models and the end-user applications sits the middleware layer — the orchestration, memory, tool integration, and state management that makes agents actually work. This is where most VC money is flowing, and it's probably where most of it will be destroyed.
LangChain raised $25 million. CrewAI raised $18 million. Microsoft's AutoGen is open source and backed by Azure. There are at least 40 agent framework startups with funding. The problem? Framework lock-in is nearly nonexistent. Switching from LangChain to CrewAI is a weekend project. These tools are thin wrappers around API calls with some orchestration logic.
The middleware layer that will have defensibility is the one that controls data flow. Agents need to read from databases, write to APIs, authenticate with services, and maintain state across sessions. Whoever standardizes that interface — the "agent integration layer" — captures real value. It's the Stripe of agents: not exciting, not glamorous, but embedded in every transaction.
NVIDIA's OpenClaw partnership is a play for exactly this. Standardized tool interfaces mean NVIDIA gets a say in how agents interact with the world. If OpenClaw becomes the default protocol, every agent framework effectively runs on NVIDIA's plumbing.
Where the Moat Actually Is
After analyzing every major player in the agent stack, here's my thesis on defensibility:
Compute: NVIDIA wins for 3-5 more years. CUDA lock-in is real. AMD's ROCm is improving but still behind on the software ecosystem. Custom silicon (TPUs, Trainium) works for hyperscalers but not the broad market. NVIDIA's position is the most defensible in the entire stack.
Foundation models: Nobody wins permanently. Open source ensures commoditization. Model advantages are temporary — each generation gets matched within 6-12 months. Anthropic and OpenAI will differentiate on safety, enterprise features, and agent-specific capabilities, but raw model performance is not a durable moat.
Agent frameworks: Nobody wins. Too fragmented, too thin, too easy to switch. Most framework startups will either be acqui-hired or die. The survivors will be the ones that move up-stack into applications or down-stack into infrastructure.
Agent runtimes: Model providers win. Claude Code's tight integration with Claude's reasoning makes it hard to replicate with a different model. Same for Operator with GPT-4.5. The runtime and the model are co-evolving — each improvement in one makes the other more valuable. This is the real reason Anthropic and OpenAI are building their own agent products instead of relying on third-party frameworks.
Applications: Vertical specialists win. The biggest opportunity in the agent stack is vertical AI agents — agents that know everything about a specific industry, integrate with the specific tools that industry uses, and automate the specific workflows that domain demands. A legal AI agent that drafts contracts, reviews precedent, and files motions. A defense AI agent that correlates intelligence, generates briefings, and monitors threat feeds. These vertical agents have the highest switching costs because they're embedded in mission-critical workflows.
The Second-Order Effects
When software writes itself, the economics of the entire technology industry change.
Developer productivity isn't linear — it's exponential. A developer using Claude Code doesn't produce 2x more code. They produce 10x more working systems because the bottleneck shifts from writing to architecting. The number of developers needed to build a given product drops by an order of magnitude. This is already happening at startups. It will hit enterprises within 18 months.
The SaaS business model faces compression. If an AI agent can replicate the functionality of a $50K/year SaaS tool for $500/month in API costs, the SaaS vendor's margin structure collapses. Not every SaaS tool is vulnerable — the ones with proprietary data, deep integrations, and regulatory compliance are safe. The ones that are essentially CRUD apps with pretty UIs are dead.
New categories emerge. Agent observability (what is the agent doing and why?). Agent security (how do you prevent an autonomous system from doing something catastrophic?). Agent compliance (who is liable when an agent makes a mistake?). Each of these will be a multi-billion dollar market within five years.
So What?
The AI agent stack is forming in real time, and the winners are becoming visible.
NVIDIA wins compute. The model labs win runtimes. Vertical specialists win applications. Everyone in the framework middleware layer should be nervous.
If you're building, build at the edges — compute infrastructure or vertical applications. The middle is a no-man's-land of zero switching costs and razor margins.
If you're investing, the safe bet is NVIDIA (they win regardless of which agent framework succeeds). The high-upside bet is vertical agent companies with domain expertise and proprietary data. The value trap is horizontal agent frameworks — they look like platforms but behave like features.
Software that writes itself isn't a future prediction. It's a present reality. The stack is forming. The positions are being taken. The question is whether you're building on a layer with a moat or one that's about to be commoditized.
Choose your layer wisely.
