Code Wasn't Built For This
From GPUs to Agents: When Tools Outgrow Their Original Purpose
There’s a familiar pattern hiding in plain sight.
The chips now training frontier AI models weren’t born in research labs. They were born rendering explosions, shadows, and pixels at 60 frames per second. NVIDIA built GPUs for video games. AI hijacked them for linear algebra at planetary scale. That repurposing worked spectacularly well. But it also created a new class of constraints, workarounds, and abstractions we are still paying down.
Programming languages are on the same trajectory now.
Python, JavaScript, C++, Go, Rust…none of them were designed for autonomous agents, long-horizon planning, probabilistic reasoning, or systems that decide what to do instead of being told how to do it. Yet here we are, building agentic AI on top of them anyway. Agreed - it works. But it just isn’t native.
Below is my argument for where the mismatch lies, why it matters and what can fill the gap.
The GPU precedent: Accidental infrastructure wins
GPUs succeeded in AI for three reasons:
Massive parallelism mapped cleanly to matrix math
Economic gravity from gaming funded relentless iteration
Software stacks evolved around the hardware, not before it
CUDA, cuDNN, Triton, kernel fusion, scheduling tricks - none of that was part of the original graphics mission. It emerged because the workload changed faster than the hardware.
Programming languages are now in the same place GPUs were in the mid-2000s.
We’re forcing new workloads through old assumptions and compensating with tooling, frameworks, and conventions.
Languages used by AI systems today
Where today’s languages break down:
Traditional programming assumes:
Deterministic execution
Known inputs and outputs
Errors are exceptional
Control flow is explicit
Agents assume:
Goals are fuzzy
Plans evolve
Partial success is normal
Failure is informative, not terminal
Outputs are probabilistic
So we fake it.
Retries become “planning.”
State machines become “reasoning.”
Logs become “memory.”
Prompt text becomes “intent.”
But here is the uncomfortable truth:
Programming languages were built to tell machines exactly what to do. Agents need to be told what matters and decide the rest.
So code struggles with: Intent, Tradeoffs, Uncertainty and Long-Horizon autonomy
We are asking languages designed for compilers to express cognition.
The gaps that keep showing up:
Intent isn’t a first-class primitive: The things that actually matter to agents — goals, constraints, and tradeoffs — live in all the wrong places. Goals end up buried in prompts. Constraints show up as comments, if they show up at all. Tradeoffs live almost entirely in the builder’s head. But agents don’t just execute instructions; they need to reason about objectives, budgets, risk tolerance, and time horizons. And today’s languages simply don’t model any of that. We’re asking systems to make decisions without giving them a native way to represent what they’re optimizing for.
Uncertainty: Large language models don’t return answers; they return distributions. But the code we wrap around them expects clean, deterministic values. So we flatten probabilities into strings, pass them along as if they were facts, and then try to reconstruct confidence later with heuristics and guardrails. The whole flow is backwards. Uncertainty is the core property of these systems, yet it’s treated as an implementation detail instead of something the language understands.
Memory is externalized: Agent “memory” today is really a collection of external systems — embeddings, vector stores, databases, logs — stitched together by convention. None of it is scoped, none of it is typed, and none of it is native to the language itself. Forgetting has to be manually engineered. Persistence is bolted on. Auditing what an agent knows, when it learned it, and why it acted on it is far harder than it should be.
Autonomy is unsafe by default: As agents move from suggesting actions to taking them, safety stops being an infrastructure problem and becomes a language problem. Permissions, sandboxes, reversibility, and explainability all start to matter at the level of semantics. Today, we handle this with wrappers, policies, and runtime checks layered on top of general-purpose languages that were never designed for autonomous actors. The result works, but it’s fragile — and increasingly hard to reason about as systems gain more agency.
This doesn’t mean “Python is dead”
Just as GPUs didn’t eliminate CPUs, agent-native abstractions won’t wipe out existing languages. What happens instead is more subtle and interesting.
New domain-specific languages will emerge. New policy and intent layers start to sit alongside traditional code. New protocols define how agents coordinate and existing languages - Python, JavaScript, Go - quietly shift roles, become execution substrates, not control surfaces.
CUDA didn’t replace C++
SQL didn’t replace C
HTML didn’t replace JavaScript
Agent-native languages won’t replace Python. They will reframe it.
Each time, a new abstraction arrived to express something the underlying language was never designed to capture. The old language stayed. It just moved down a layer. The same thing will happen here. Agent-native languages aren’t coming to replace Python. They’re coming to reframe it — to move Python from being the place where intent, logic, and control are all tangled together into a lower-level runtime that executes decisions made elsewhere.
And this brings us back to the NVIDIA analogy, GPUs succeeded because the workload forced evolution, the software stack adapted to reality and developers were forced to change how they thought about performance, parallelism, and control. Over time, the mental model shifted, and the ecosystem followed.
We are early in that same cycle for agentic software.
Today’s languages look a lot like the fixed-function graphics pipelines of the 1990s. They are powerful, but misaligned. Flexible, but leaky. Capable of doing the job, yet constantly fighting the shape of the problem they’re being asked to solve.
The next leap won’t come from a slightly faster model or a marginally better benchmark. It will come from a better way to express intent, to reason about uncertainty, and to grant autonomy safely.
That’s where the real platform shift is hiding — not in more intelligence, but in how we tell intelligence what matters.
The views expressed are those of the author and do not necessarily reflect the views of any investment firm or portfolio company.