Cover photo: Jensen Huang at CES, January 2017, by Maurizio Pesce, licensed CC BY 2.0, via Wikimedia Commons. Cropped.
The most useful part of Jensen Huang’s Y Combinator interview is not the NVIDIA origin story. It is a stretch of about eight minutes, starting near the 21-minute mark, where he explains how AI agents actually work, what is still broken about them, and why he thinks an open-source agent framework is as important as Linux.
The conversation, The Mindset That Built NVIDIA, was recorded with YC president Garry Tan in front of roughly 6,000 founders at Startup School and published in late July 2026. Most coverage focused on the early pivots and the management philosophy. I want to focus on the agent section, because it is the clearest explanation I have heard from a CEO at that level of where the real value in AI is moving.
My summary of his argument: the model is no longer the whole product. The system around the model is. That system holds the memory, the tools, and the controls, and whoever builds it well ends up with an AI that gets better every time it is used.
The short version
Huang makes three claims in this section, and each one builds on the last.
- Agents already improve themselves. Not by retraining the model, but by rewriting their own notes and memory every time they run.
- The unsolved problem is control. Agents are getting smarter faster than we are getting better at steering them.
- The agent framework is the new operating system. He calls OpenClaw a Linux moment and says everyone can now build their own AI.
If you only remember one thing, remember this: the intelligence is rented, but the memory and the controls are yours. That is the part worth owning.
Claim 1: Agents already improve themselves, through memory
At about 21:35, Huang says we already have what he calls “coarse-level recursive self-improvement.” That phrase usually belongs to science fiction: an AI that rewrites itself into something smarter. His version is far more ordinary, and far more real.
What he is describing
A modern agent is a language model wrapped in a working environment. That environment includes plain text files, usually markdown, where the agent keeps instructions, notes about your preferences, lessons from past mistakes, and summaries of earlier work. Huang’s point is that every session leaves those files a little better than it found them.
He then describes a second, slower loop. Long-term memory is processed in the background. It gets compacted into shorter summaries or organized into knowledge graphs, and this happens asynchronously, meaning while you are not using the agent at all.
So there are two loops running:
- The fast loop: during a task, the agent updates its notes with what it just learned.
- The slow loop: between tasks, a background process cleans, compresses, and reorganizes that memory so the next session starts smarter.
Why “coarse” is the right word
The model’s weights never change. The underlying intelligence is exactly as capable on day 100 as on day 1. What changes is the context the model is handed at the start of each task.
Think of a talented new hire. Their raw ability does not change much in the first six months. What changes is that they learn your clients, your terminology, your way of doing things, and where the bodies are buried. An agent with good memory goes through the same onboarding, except it writes everything down and never forgets it.
Why this matters for a business
This is the difference between using AI and compounding with AI. A chat window with no memory gives you the same generic assistant every morning. A system with persistent memory gives you an assistant that knows your business a little better every week.
It also means the memory layer is an asset. The notes, the summaries, and the structured knowledge your agents accumulate are specific to your company. A competitor can rent the same model you use. They cannot rent your memory.
Claim 2: The unsolved problem is fine-grained control
Right after describing agents that keep getting smarter, Huang turns to what is still missing. The problem he wants everybody to work on is control at a very fine grain.
Prompts are too coarse
His complaint is about the basic shape of how we use AI today. You type a prompt, the model produces an output, and everything in between is a black box. If the output is 90% right, your options are poor. You can rewrite the prompt and hope, or fix the result by hand.
He credits the techniques that already narrow this gap. Retrieval (RAG) lets you control what the model knows. Conditional inputs let you constrain what it produces. Without those, he says, prompt-to-output would be too blunt an instrument to be useful.
What fine-grained control looks like
The example he gives is the plan. A good agent does not jump straight to the answer. It first writes out a plan for how it will do the work. Huang wants to be able to change a single word in that plan and have everything downstream adjust to match.
That is a different relationship with software. You are not rerolling the dice. You are editing the reasoning at the exact point where it went wrong, the way a manager corrects one assumption in a colleague’s proposal instead of asking for a new proposal.
Control beats raw accuracy
According to one detailed writeup of the talk, Huang went further and said he would choose an agent that is 80% accurate but precisely steerable over one that is 99% accurate and cannot be steered.
That sounds backwards until you think about how work gets done. A 99% system that fails unpredictably cannot be trusted with anything important, because you cannot find or fix the 1%. An 80% system you can inspect and correct at each step gets to a finished, reliable result. Trust comes from control, not from a benchmark score.
What this means in practice
If you are building or buying agent systems, controllability should be a design requirement, not a nice-to-have. In practical terms:
- Plans are visible and editable. The agent shows its plan before it acts, and a person can change it.
- Work happens in checkpoints. Long tasks pause at defined points for review instead of running to the end unattended.
- Instructions live in files, not in someone’s head. The rules the agent follows are written down where they can be read, versioned, and corrected.
- Every action leaves a trail. You can see what the agent did, with what inputs, and why.
Why a chip company cares this much about agents
Tan asks the obvious question: why is the CEO of a hardware company this deep in the details of agent software? Huang’s answer, at about 23:51, is that agents are the new software, and the way software runs determines how computers should be built.
This is consistent with how he describes NVIDIA throughout the interview. The company does not see itself as selling chips. It sees itself as designing whole computing systems around the workload of the moment. If the workload changes, the computer has to change.
And the workload has changed. Here is my reading of the difference he is pointing at:
| Dimension | Chatbot | Agent |
|---|---|---|
| Unit of work | One question, one answer | A task with many steps |
| Duration | Seconds | Minutes to hours |
| Model calls | One | Dozens or hundreds, in a loop |
| Outside the model | Almost nothing | Tools, files, code, search, other agents |
| Memory | The current conversation | Persistent files and long-term stores |
A chatbot is mostly one burst of model computation. An agent spends its time moving between the model, its tools, and its memory, over and over. That shifts where the bottlenecks are, which is exactly the kind of thing a systems company needs to understand before it designs the next generation of hardware.
The lesson for the rest of us is simpler. When the person supplying most of the world’s AI compute says he is reorganizing around agents and not chatbots, that is a strong signal about where the next few years of software are headed.
Claim 3: OpenClaw is the Linux moment
Around 28:30, Huang describes the agent framework as the operating system that holds a large language model, and says OpenClaw felt to him like a Linux moment.
What OpenClaw is
OpenClaw is an open-source framework for running AI agents, created by developer Peter Steinberger. You start an agent with a single command, then direct it in plain language. From there it can call models, use tools, read files, launch sub-agents, and carry out multi-step tasks.
Notice what is missing from that description: a model. OpenClaw is not an AI. It is the layer around the AI, often called the harness. You plug in whichever model you prefer.
Why the Linux comparison fits
Before Linux, operating systems were proprietary. If you wanted to build a computing product, you licensed someone else’s foundation and lived inside their rules. Linux gave every company a free, shared base that anyone could inspect, modify, and build on. Most of the internet now runs on it.
Huang’s argument is that OpenClaw plays the same role for agents. He made the comparison publicly at NVIDIA’s GTC conference in March 2026, where he said the project had spread faster than Linux, Kubernetes, or HTML and told the audience that “every company in the world today needs to have an OpenClaw strategy.”
The operating system framing also explains the first two claims. An operating system manages memory, runs processes, and enforces permissions. An agent harness does the same things for a language model: it manages what the model remembers, what it is allowed to run, and what it is allowed to touch.
What NVIDIA did about it
In the interview, Huang says NVIDIA reached out to Steinberger and offered the full weight of its engineering organization, with Steinberger free to split up the problem however he saw fit. His image for it: a battleship parked outside your house.
The visible result is NemoClaw, NVIDIA’s reference design for running OpenClaw safely inside a company. It exists because of a real problem. An agent inside a corporate network can reach sensitive data, execute code, and talk to the outside world, and that combination is dangerous without guardrails. NemoClaw adds an isolated sandbox called OpenShell, policy controls, and a privacy router that keeps sensitive data local while still letting agents use cloud models.
That last detail connects directly to Claim 2. The enterprise answer to powerful agents is the same as Huang’s personal wish list: more control.
Build your own AI, and still use the cloud
It would be easy to hear the Linux comparison as an argument against the big AI providers. Huang closes that door himself. At about 29:06 he says the world needs the ability for everybody to build their own AI, and in the same breath encourages people to use cloud services, naming ChatGPT and Claude, as much as possible.
These two positions only conflict if you think “your own AI” means your own model. It does not. Very few companies should train or even host a frontier model. What Huang means is the system around the model:
- Rent the intelligence. Frontier models from the major providers are the best reasoning engines available, and they improve on someone else’s budget.
- Own the harness. The memory, the tools, the instructions, the workflows, and the controls should belong to you, live in your environment, and encode how your business works.
The two halves have very different economics. Models are becoming interchangeable. A better one ships every few months, and switching is often a one-line change. Your harness is the opposite. It accumulates value over time, and it is specific to you.
There is also a practical safety net here. If your memory and workflows live in your own system, a price increase, an outage, or a better competitor is a configuration change. If they live inside one vendor’s chat product, it is a migration project. We made the same case for not betting on one model.
What this means for your business
You do not need to install OpenClaw to act on any of this. Huang is describing an architecture, and the architecture is what matters. Every serious agent system, whatever it is built with, ends up with the same parts.
| Part | What it does | The question to ask |
|---|---|---|
| Model | Reasons and plans | Can we swap it without rebuilding everything? |
| Memory | Stores what the system has learned about our business | Do we own it, and does it improve with use? |
| Orchestration | Runs multi-step work, schedules, and background jobs | Does work continue when nobody is at the keyboard? |
| Tools | Connects to our real systems: CRM, email, files, databases | Can the agent act, or only talk? |
| Visibility | Shows what agents did and lets people step in | Can a person see the plan and change it? |
This is the same structure I use with clients: a brain, a memory, a nervous system, hands, and eyes. Huang’s three claims map onto it cleanly. Self-improvement lives in the memory layer. Control lives in the visibility layer. The operating system is all five working together.
A practical starting sequence
- Write things down first. Before any automation, capture how your business works in plain documents: processes, client context, tone, rules. This becomes the first version of your agent’s memory, and it is useful even if you stop here.
- Pick one workflow that repeats weekly. Reporting, lead follow-up, intake, research. Something with a clear start, a clear finish, and a person who can judge the result.
- Build it with a visible plan and a review step. The agent proposes, a person approves or edits. Resist full autonomy until the corrections become rare.
- Feed corrections back into memory. Every time someone fixes the agent’s work, that fix should become a written rule. This is the self-improvement loop Huang describes, and it is where the compounding starts.
- Keep the model replaceable. Avoid designs where your knowledge is trapped inside one provider’s product.
- Treat security as part of the design. Decide early what agents may read, what they may change, and what always requires a person.
Three mistakes to avoid
- Chasing the best model. The gap between top models is small and temporary. The gap between a company with accumulated memory and one without grows every month.
- Automating before documenting. An agent with no written context will confidently do the wrong thing, quickly.
- Measuring accuracy and ignoring steerability. Ask how easily a person can catch and correct a mistake, not only how often mistakes happen.
The takeaway
For two years the AI conversation has been about which model is smartest. Huang is telling a room of founders that the question has moved. The model is a component. The system that surrounds it, remembers for it, and keeps it under control is the product.
That is good news for companies that are not AI labs. You cannot out-train the frontier providers, and you do not have to. You can build the layer they cannot build for you: the one that knows your business, improves each time it is used, and does what you tell it to at the level of a single word.
The companies that start building that layer now will have a year of compounding memory by the time their competitors pick a chatbot.
Sources
- Jensen Huang: The Mindset That Built NVIDIA, Y Combinator, published July 26, 2026. Agent discussion runs from roughly 21:28 to 29:30.
- Jensen Huang Bet Wrong, Told the Truth, and Built a $5 Trillion Company, The AI Corner, August 3, 2026.
- Nvidia GTC: OpenClaw is the new Linux, and every company needs a strategy, says Jensen Huang, Fierce Network, March 2026.
Own the layer that compounds
STRAVYNT builds the harness around the model: your instructions written down, memory that improves with every correction, and a person approving anything that reaches a customer or moves money.