Cursor just hit $2 billion in annualized revenue. Its valuation sits at $29.3 billion. Jensen Huang went on CNBC and called it his favorite enterprise AI service, noting that all 40,000 Nvidia engineers use it daily.

And yet, when Jerry Murdock sat down for his first-ever long-form podcast interview on 20VC last month, the AI-native companies in his portfolio told him something that sounds absurd on the surface:

But who is Jerry Murdock?

He co-founded Insight Partners in 1995. The firm now manages over $90 billion. He backed Twitter in 2009, when it had thirty employees and zero revenue — a bet that became a textbook venture capital case study. He also invested in Docker, Snapchat, and a long list of companies that reshaped internet infrastructure. His timing across three decades of tech inflection points has been almost surgically precise.

Murdock never does interviews. The fact that he chose this moment to break that silence is itself a signal.

I watched the full conversation (just an hour+), and it kinda reframe how I think about everything we build as software engineers. The core argument is disarmingly simple, and the implications are enormous for me.

Murdock opened with a metaphor that stuck with me for days.

Think of the current AI wave as a tsunami. When a tsunami is still out in deep ocean, it’s invisible — you could sail right over it and not notice a thing. The destructive force only reveals itself when the wave reaches the coastline.

Everything we are watching now — stock volatility, SaaS valuation resets, layoffs, the daily drumbeat of AI announcements — all of that is the earthquake that triggered the wave. These are tremors. Warnings.

And the main wave isn’t better models or bigger context windows.

It’s autonomous agents.

You might be thinking: “Yea, so what. I had already knew it.”

But the distinction matters more than most people realize.

Right now, tools like ChatGPT, Claude, and Cursor are assistants. You provide the instruction, they provide a response. You guide, correct, and decide throughout the process. The human remains the subject; AI is the tool that helps.

You give them a goal. They decompose it into subtasks, make a plan, choose which tools to use, execute, verify results, and close the loop end to end — without a human in the middle.

Murdock’s framing was direct: agents are not your assistants. They are your employees. You give them credentials, you give them an identity, and the decision-making becomes theirs.

If agents become the primary consumers of software, a question follows naturally:

“Is the infrastructure we have built over the past two decades — designed entirely for human perception, human reaction times, and human decision-making — still fit for purpose?”

Murdock gave an example that answered that question with uncomfortable clarity.

He invested in E2B, a company that builds sandbox environments — isolated containers where agents execute and test code. It sounds like basic infrastructure. Low-margin plumbing that most people would overlook.

Then he shared a number that changes how you think about the problem.

Humans perceive system latency at around 400 milliseconds. That’s why most mobile operating systems use 400ms as their responsiveness threshold — stay under that, and users feel zero lag. E2B’s sandboxes cold-start in roughly 80 milliseconds. To a human, those two numbers feel identical. You literally cannot tell the difference.

But imagine an agent that needs to spin up 100,000 sandboxes simultaneously — testing the same task across ten different models, in parallel, at machine speed. At 80ms per sandbox, the system flows. At 400ms, it buckles under its own weight, or collapses entirely.

This is not a marginal optimization problem. It’s a fundamental mismatch between two different design paradigms. The latency threshold we have treated as “good enough” for decades is not good enough when your user is a machine operating at a completely different scale.

And it extends well beyond latency. When agents become the primary consumers of software infrastructure, the pricing model changes — Docker, another Murdock portfolio company, is already shifting toward consumption-based billing because agents don’t purchase annual seat licenses. They call resources on demand and pay by usage. The concurrency requirements change. The security model changes. The API design standards change.

Nearly every assumption baked into how we build software today was shaped by one constraint: the human at the other end. Remove that constraint, and the design space reopens from scratch.

This is why Murdock’s comment about Cursor makes sense — and why it isn’t actually about Cursor at all (I will explain).

Cursor’s product is built on a specific premise: the human writes code, and AI assists. The developer sits in the IDE, reads suggestions, accepts or rejects, and iterates. Cursor is the best copilot in the business.

But when an autonomous agent can take a GitHub issue, decompose it, write the code, run the tests, fix the failures, and open a pull request without anyone touching the IDE — the value of a copilot shifts. It doesn’t disappear. But its importance drops by an order of magnitude, the same way asking strangers for directions didn’t vanish when GPS arrived, but became something you almost never need to do.

Murdock was clear on this: Cursor has smart people, significant capital, and a massive customer base. The team has time to adapt. The structural challenge is that their core model supplier — Anthropic — is now a direct competitor through Claude Code. And the AI-native companies Murdock talks to daily have already moved to autonomous coding workflows as the default.

In an industry that iterates by the month, starting to enter the agent space while competitors already live there is a gap that matters.

Cursor isn’t the story here. It’s the illustration. Any product built on the assumption that a human is the primary operator faces the same question: what happens when the operator changes?

Murdock drew a historical parallel that most builders will feel in their bones.

In 2003, building a website required Sun servers and Oracle databases. Infrastructure costs alone could kill a startup before it shipped a single page. Then the LAMP stack appeared — Linux, Apache, MySQL, PHP — four open-source components that dropped the cost of deploying a website to nearly zero. That stack powered the internet explosion of 2004–2005. Google’s IPO rode the same wave.

Murdock believes we are standing at the same inflection point for agents. He described a three-layer “Agent Stack” — and the gap in the middle is where the biggest opportunity lives.

The Inference Layer is the foundation. These are the models — Claude, GPT, Gemini, DeepSeek, Llama, Qwen.

This layer is maturing fast. Competition is fierce, capabilities improve every few months, and pricing is in a race to the bottom.

The Execution Layer is at the top. This is where agents actually perform actions — running code in sandboxes, browsing the web, manipulating files, calling APIs. Companies like E2B and Docker are building the infrastructure for this.

The Orchestration Layer sits in the middle, and this is the layer that barely exists yet.

To understand why it matters, think about how software works today. When you build an application that uses an LLM, you — the developer/engineer — choose which model to call. You read the benchmarks, compare the pricing, test a few options, and hardcode your choice into the application. “Use Claude Opus for this task, and GPT for that one.” The human is the router in this case.

In an agent-driven world, this manual routing disappears. The orchestration layer becomes an automated dispatch system.

A task comes in. The layer decomposes it into subtasks. It looks at each subtask’s requirements: does this need deep reasoning or just text processing? Does accuracy matter more than speed here, or is cost the priority? Then it routes each one to the best-fit model automatically.

Murdock described how this actually works in practice: an agent spins up ten isolated sandboxes, runs the same task on ten different models in parallel, compares every result, and selects whichever model delivered the best balance of quality and cost. No brand loyalty is considered. No reputation bias is applied. Pure performance-based selection, driven by data the human never sees.

The implications ripple outward. If agents choose models the way they choose anything else — by testing, comparing, and optimizing — then every foundation model faces commoditization pressure.

The company that controls the orchestration logic controls which model gets the traffic. Control the routing, control the workflow. Control the workflow, control the value chain.

This is also why open-source models become structurally more important in an agent-first world. When the selection process is purely algorithmic, brand premium evaporates. If DeepSeek or Llama can handle 80% of subtasks at a fraction of the cost, the agent will route 80% of the work there — regardless of which model has better marketing.

For builders, the practical question is: are you building tools that an orchestration layer can discover, call, and evaluate? Or are you building tools that require a human to read the documentation, configure the integration, and manually decide when to use them?

Because agents won’t read your docs. They won’t browse your marketing site. They won’t watch your demo video. They will query a registry, check your tool’s declared capabilities, test whether it delivers, and either route traffic to you or move on.

Not gonna lie, it’s hard for me to tweak my mindset around this, as someone who has been practicing in software engineering field for quite a while.

At the end of the conversation, Murdock circled back to the tsunami again.

The main wave hasn’t hit. The warning window is open. Some companies will use it to rebuild — rearchitect their APIs for agent consumption, redesign their pricing for machine-speed usage patterns, retool their infrastructure for the concurrency demands of a world where your heaviest user isn’t a person but a fleet of autonomous processes.

Some won’t.

The ones that don’t won’t die in a dramatic collapse. They will erode gradually — their data growing stale, their integrations bypassed, their value hollowed out as agents route around them to reach tools that speak their language. Murdock’s word for it was precise: their data becomes “valueless databases.”

The question for every builder is the same one Murdock posed, using the simplest possible framing:

For me, this interview was the push I needed to go deeper into the two pieces of infrastructure that will define how agents actually interact with the world: the Model Context Protocol (MCP), which is quickly becoming the standard for how agents discover and use tools; and Context Engineering, the discipline of managing what information an agent sees at each step of a task.

Understanding these two concepts is essential for any builder who takes the agent shift seriously — and that’s exactly what I will be breaking down next.

Zero Address covers Chinese AI technology for English-speaking builders. I read the Mandarin tech docs so you don’t have to. Subscribe to get weekly deep dives delivered to your inbox.