Author: Sarah Guo
Translation: Deep Tide TechFlow
Deep Tide Introduction: When large models begin to crush humans on all leaderboards, investors are falling into a kind of despair: what is worth investing in besides Anthropic and Nvidia? This top Silicon Valley investor explains with data and case studies that the real moat isn't on the leaderboard—it's hidden in places that cannot be measured by benchmarks.
Mid-2026, the investor version of AI psychosis is despair: There's nothing worth investing in, we should just put all our money in Anthropic and Nvidia and go home.
I've never felt this way. I'm already convinced the model is several minor versions smarter than me, I'm happy to buy Anthropic and Nvidia at market price, and all my smartest friends are fairly convinced self-improvement will succeed soon—but I still don't feel this despair.
This despair is not stupid. The logic is this: if models keep getting better at everything, then every company built on them is just a thin layer of wrapping, waiting to be absorbed, and the only value that survives is compute power and frontier weights.
Take software as an example, the case despair theorists rely on most. When Devin launched in 2024, it could only solve 13% of tasks on standard software benchmarks, basically ignored. A year and a half later, the best agents score in the 80s, and they're doing real work inside Goldman Sachs and the U.S. Army. Almost everyone draws the same wrong lesson: the model ate software engineering. But as the model devours the most measurable parts of software engineering, we're rediscovering what many teams have long known—engineering has always resisted measurement, and the easiest part to measure may not be the only important part.
MIT's Mert Demirer and his collaborators finally put numbers to it: among over 100,000 developers, the latest coding agent increased the amount of code written by about 180%, while the amount of code actually shipped increased by about 30%. Writing code got cheaper. The remaining parts still have to go through people, and they matter. Of course, the net impact is still staggering.
Benchmarks are things you can measure, and what you can measure is what you can train for. Therefore, coding agents matured first: compilers are free verifiers, test suites are free verifiers, when the answer checks itself for free, you can grind against the check until you beat it. But passing the tests never tells you whether that change is the right one for a decade-old codebase with three undocumented modules whose reason for existing, and a deployment pipeline held together by a cron job nobody will admit to writing.
That kind of correctness cannot be read from a leaderboard, and in fact cannot be read from anything. You learn by running in the real world long enough to discover whether such a complex system works, and smarter models don't make the world run faster. Nobody runs unit tests on something Google-scale and trusts the green check; you trust it because it has weathered years of real load. Such correctness isn't just private, it's the slow kind of moat that capital can't bulldoze. Even optimists admit the clock cannot be skipped: Noam Brown, pioneer of reasoning models at OpenAI, recently wrote that the only reliable way to evaluate an agent over a year-long timescale might just be... to run it for a year.
As Gabe Pereyra says, true automation is not just the model getting better. It's the product, model, workflow, and company all moving together, and three of those four move at the speed of organizations.
The people-moving part is what benchmarks don't touch: getting a skeptical partner to change how she handles matters, keeping the team together through the rebuild. That's why when we hire a CEO, the ability to handle people matters at least as much as analytical skill, and smarter models won't change that weighting. Feedback is fuzzy, the timescale is years, trust is personal. Every company I know gave every engineer access to frontier coding models, but none of them changed their engineering org anywhere near that speed. Adoption took a quarter, what a magical token growth quarter that was! But the rebuild is taking years.
What's visible is what's leaving. Valuable work is structurally invisible: anything you can put on a leaderboard, you can train against, so anything measurable is already on its way to commoditization. This process takes time and never fully completes, but the direction never reverses. In the monetary terms of my friend Matt MacInnis at Rippling: tokens spent answering generic questions are almost worthless because anyone's model can answer it, while tokens spent reasoning over your company's data are worth much more because they do what you actually want, not just what looks plausible.
Visible work gets eaten from two sides. From below, task saturation: once a job can be cheaply checked, buyers stop asking which model did it and start asking how much it costs, and the job falls to the cheapest open-source or distilled model that week. Wherever they can have impact, margins matter in the end. From above, labs are trying to get the model to devour its own scaffolding. Retrieval, routing between cheap and expensive calls, tool use, even reasoning strategies, all the apparatus that used to wrap the model gets pulled into the weights until the wrapper is the model. That's frontier absorption. Margin pressure cuts the other way too: a general-purpose agent has to be ready for anything, which is expensive, while a focused app can tune a workflow until it runs on a fraction of the token spend, and unlike the lab selling those tokens, it keeps the spread.
So, we can ask two things about any type of work. Is its correctness private and expensive to build, the kind of truth that exists only inside someone's data? Is it isolated, locked inside systems you cannot enter? Contrast these against how saturated the task is, and you get a 2x2 matrix. Saturated work with public answers is commodity tokens, owned by open-source models. Frontier work with public answers, where coding benchmarks live, is where labs win, because when evaluation is free, owning it costs nothing. The prize is in the last corner, the untrainable one: frontier work whose correctness exists only in private domains. You can see this in the inference clouds hosting AI-native pioneers, where the vast majority of tokens are generated by bespoke models, not general-purpose open-source ones.
The walls into that last corner vary in height. A single developer's toy codebase is portable and standardized, so the climb is short. A bank's production system is neither, and you don't get root access by being 2% smarter on SWE-Bench Verified.
Capability eats many things, but a better model does not make a private ground truth public. It doesn't hold the license, sign the liability, or own the firm's documents, and it cannot be the party sued when the answer is wrong. Intelligence isn't the bottleneck here. Licensing is, and so is liability. You can imagine a model far smarter than anyone, and it still must be allowed through the door, and someone still must sign their name to what it does.
That door has a lock and a bolt. The lock is context: you only get to validate whether the AI did useful things after being trusted inside the system, after security reviews, integration, the contract where you sign your name to the result. The bolt is the user. Most doctors in the U.S. now open OpenEvidence every day, and no amount of compute can buy that. A lab could train a perfect medical model tomorrow and still fail to get into a doctor's habit, or into UCSF's decision flow, because trust is built slowly, on relationships, requiring the user's acquiescence, not erasing it with gradient descent.
This too is work. An app earns its place in the untrainable corner by doing unglamorous work: arranging the company's private reality so the model can act on it, giving the model tools to act, working with the customer to change the reality of their employees. A company that brings the translation is hard to copy—and the translation never ends. Integration and maintenance last as long as the relationship, won by teams that put domain-specialist engineers and tools next to the customer.
For example, at a top white-shoe law firm, the M&A practice alone runs nearly a thousand deals a year. For confidentiality and many other reasons, you can't have hundreds of associates each downloading client files to their desktop and asking a general-purpose agent to sift through them, and even if you could, what you'd learn would be piecemeal, one associate's correction at a time, missing how the whole deal flows. The important signal exists at the deal level, and a deal has a shape: for M&A, it's NDA, term sheet, due diligence, purchase agreement, ancillary documents, closing checklist; for IP litigation, it's motions, discovery, prior art, more motions. Each practice area has its own, and lawyers and tools are not interchangeable across them. And the problem the law firm actually solves sits a level above all this: running every practice area in parallel, like a top partner running hundreds of matters at once while onboarding new ones and training associates. Transforming such a law firm is not a single task you can write an eval for. It requires an operator to do what the analytics firm does, with incredibly fuzzy goals, incomplete feedback, long timescales, in an environment that won't stay still.
Unfortunately, invisible value is also hard to sell, for the same reason it's hard to commoditize: companies can't tell from the outside whether AI will transform their ops, just as a benchmark can't tell. So the strongest enterprises stop trying to prove it from the outside and go inside, pricing on outcome. Sierra charges when its agent resolves a customer issue, not when it kicks it to a human, so price becomes the evaluation, which only works because Sierra owns the definition of "resolved." Cognition's Devin does the same move in software, offering a "performance guarantee," which you can only give for outcomes in systems you are trusted inside.
Even serving tokens, the layer everyone loves to call a pure commodity, doesn't act like one. The best AI-native companies concentrate their serving on one or two providers (Baseten or Fireworks) because per-token cost commoditizes on schedule, while reliability at real traffic and guaranteed access to scarce compute do not. Where you serve is a separate choice from which models you use. Price is the only part of inference that acts like a commodity.
A common objection raised is that the lab is your supplier—why wouldn't it run its own first-party product below cost to bleed you dry, or revoke your API access and take the market itself? This is the real version of despair theory, and it only works if the model layer is a single-player game. It's obviously not—it looks more like a deathmatch between three and a half parties, with a pack of international players six months behind on training, and a G League five times the size of last year's. Customers want competition among suppliers, and labs want market share more than they want any single app dead.
You can see this in markets where labs go head-to-head. In consumer chat, the best model never simply wins. ChatGPT held the lead for years in real competition, and the share it's losing now is going to Gemini, on the strength of Android and search, not a better model. Anthropic, currently rated by prediction markets (and internet vibes) as having the best model, is barely a factor in consumer chat but built its business in enterprise and coding instead. If a better model cannot take users from a competitor in the most core application, it won't make it through a hospital's records or a bank's liability by integration. The public's choice today is not based on coding alone. If the frontier stays crowded, the layer above it will be valuable.
If work can't be scored from the outside, someone inside has to decide what even counts as a good answer, and that decision is the whole game. Enough of those decisions, written down, becomes a benchmark. Harvey released one for law, Sierra for voice agents. You earn the right to define what good means for a domain by being the one that domain already uses, and these companies won that right through the fight of real adoption.
The evaluations that decide real money are private and vary by company: this firm, on this matter, will accept what as good work, and it's nowhere near done because the depth of law dwarfs any public test. OpenEvidence is establishing what a safe clinical answer looks like. These are not really measurement, this is judgment about what's true and what's good, written down until it becomes the standard by which everyone else is measured, and the underlying lab, however smart, cannot write it because that status exists only inside the domain. That authority tends to land where it already sits. Senior lawyers write the law benchmark. Defining safe clinical answers falls to doctors. And what resolved means is whatever the company that already has the customer says it means.
The frontier of absorption keeps rising because we keep learning to measure more work, and the measurable gets eaten. The untrainable ground shrinks under the feet of whoever stands on it, so you cannot find a defensible point and rest. You keep moving toward whatever still can't be scored, you keep re-underwriting. On a narrow task, with your private data and your own evaluations, you can fine-tune to the frontier and beat the general-purpose model where it matters, and that specialized model becomes part of the moat. On the other hand, competing on the general-purpose model is a capital war you lose to whoever has the most compute, the trap for companies with shallow access and visible tasks. The day it promises survival by out-training the frontier on general tasks, the winner seems most determined by datacenter scale, and the end is usually not an independent champion but a sale to someone compute-rich.
All this is defense. The harder part is offense, choosing what to build in the first place. This is what I spent a year looking for, and I might have found it three times. The model doesn't help here. It will do whatever you point it at, but can't tell you what's worth pointing at, you cannot benchmark that, so you cannot train it. This is also why incumbents won't take everything: they hold the ground they have, and the next thing comes from whoever spots a use before the rest of us. Perhaps intention is a scarcer input than compute.
The despair theory is half right. The thin wrapper layers are indeed being absorbed, and a lot of what looks like a company today is a thin wrapper. It's wrong about what's left. The mechanism is clear; the destination is not. What I'd bet on is the direction: intelligence keeps getting cheaper, and value keeps sliding toward the few places the model cannot reach. The untrainable is value with history. So get into one, do the unglamorous translation, start writing down what good means there, because someone will. This year's most cited benchmark score is a map of territory about to become worthless, and a notice of who's about to lose the right to say what counts as good.
