The ledger does not lie, but the CEOs do. Vercel's CEO just dropped a bombshell that most of the AI world is too busy polishing their press releases to notice. Open-source models now command 62% of all tokens processed on Vercel's platform. Two months ago, that number was 28.4%. This isn't a trend. This is a hostile takeover executed at machine speed.
I've been tracking model adoption curves since the ETC fork days, and I've never seen a shift this violent. The block explorer reveals what the headline hides. DeepSeek, a Chinese open-source model, just leapfrogged Google to become the second-largest model provider on the platform. Google. The company with Gemini, DeepMind, and more research papers than anyone else on the planet. Sitting in third place behind a model that costs pennies to run.
Let me be clear about what this means. The developers building the future of the web have voted with their API calls. And they've chosen open source. Not because it's ideologically pure. Because it works.
The Context: Vercel as the Neutral Observer
Vercel is the deployment layer for the modern web. If you're building a Next.js app, a headless commerce site, or an AI-powered frontend, you're probably touching Vercel. Their AI Gateway routes requests to multiple model providers, which makes them the perfect neutral observer. They don't have a horse in the model race. They just watch the traffic flow.
And the traffic flow has become a flood. The total token volume on Vercel's platform is accelerating. OpenAI and Anthropic are both seeing absolute usage growth. But their market share is being eaten alive. This is the classic "rising tide" scenario, except the tide is carrying open-source boats while the luxury yachts stay anchored in the harbor.
The data point that should terrify closed-source vendors: open-source models went from 28.4% to 62% token share in roughly two months. That's not a gradual migration. That's a stampede. Developers don't switch models for ideological reasons. They switch because the alternative is better, cheaper, or both.
The Core: The Great Value Divergence
Here's where the numbers get ugly. Open-source models handle 62% of the tokens but only account for 8.6% of the spending. Closed-source models handle 38% of the tokens but command 91.4% of the revenue. Do the math. The unit economics are staggering.
Open-source tokens cost roughly 1/14th of their closed-source counterparts. That's not a technical cost difference. That's a pricing strategy. DeepSeek and its open-source peers are running penetration pricing. They're selling tokens at near-cost to capture market share and build ecosystem lock-in. It's the classic Amazon playbook. Lose money on every unit, make it up in volume.
But here's the part that keeps me up at night. Anthropic uses 30% of the tokens but captures 65.1% of the spending. That's not just a premium. That's a monopoly on high-value tasks. Developers are paying $3/$15 per million tokens for Claude 3.5 Sonnet when they could use DeepSeek for a fraction of the cost. And they're doing it willingly.
Why? Because some tasks are worth more than others. Complex code generation, agentic workflows, long-document analysis. These aren't commodity tasks. They're high-stakes operations where a single error costs more than the entire API bill. The market has spoken: open source wins the volume war, closed source wins the value war.
Based on my experience auditing smart contract logic and tracking on-chain movements, I can tell you this pattern is familiar. It's the same dynamic we saw in DeFi. Uniswap captured the retail flow, but institutional money stayed with centralized exchanges. The infrastructure was different, but the psychology was identical. People pay for trust when the stakes are high.
The DeepSeek Signal: More Than Just Cheap Tokens
Let's talk about DeepSeek specifically. This isn't just a price war. If it were, developers would migrate back to closed source the moment quality dipped. The fact that DeepSeek has sustained its growth over two months means the quality is real.
DeepSeek's architecture is the secret weapon. They're using Mixture-of-Experts (MoE) with Multi-head Latent Attention (MLA). This isn't just an incremental improvement. It's a fundamental rethink of how to optimize inference costs. The result is a model that delivers GPT-4o-level performance on code and Chinese-language tasks at a fraction of the compute cost.
I've been running my own tests since the DeFi Summer days. I deployed $5,000 into new Uniswap V2 pairs to test liquidity mining rewards. I'm applying the same hands-on approach to model evaluation. I've thrown my own codebases at DeepSeek, GPT-4o, and Claude 3.5. The results are surprising. For refactoring, test generation, and documentation, DeepSeek is indistinguishable from the closed-source giants. For complex architectural decisions, the gap is still there. But it's closing fast.
The hidden story here is the long tail. That 62% token share isn't all high-value reasoning. A significant chunk is batch processing, embeddings, simple classification, and other low-complexity tasks. Developers are offloading their commodity work to open source while keeping their crown-jewel tasks on premium models. This is the "good enough" threshold being crossed. And once that threshold is crossed, it never goes back.
The Contrarian Angle: The Cost Illusion
The narrative forming around this data is that open source is winning. I'm not so sure. The 8.6% spending figure only captures API costs. It doesn't include the hidden costs of self-hosting. GPU infrastructure, DevOps overhead, engineering time, security patching. When you factor in total cost of ownership, the open-source advantage shrinks dramatically.
I've seen this play out in the crypto world. Everyone talks about the low fees of decentralized exchanges. But when you factor in slippage, gas costs, and the risk of smart contract bugs, the savings evaporate. The same logic applies here. A developer running DeepSeek on their own infrastructure is trading API costs for infrastructure complexity. That's not always a winning trade.
Here's the contrarian take that nobody's talking about: the open-source token surge might be a leading indicator of a quality downgrade. When developers migrate their workloads to cheaper models, they lower their quality expectations. They accept "good enough" outputs because the cost savings justify the compromise. This creates a feedback loop. The more they use open source, the more they accept its limitations. And the less pressure there is on open-source developers to improve.
This is the "quality ratchet" effect. It's the same dynamic that killed the premium blogosphere when social media took over. The market optimized for volume and speed over depth and accuracy. We're seeing the same thing happen in AI. The 62% token share might represent a race to the bottom, not a leap forward.
The Google Problem: Research Strength Doesn't Equal Product Strength
Let's talk about Google's fall to third place. This is a signal that should worry anyone who believes research superiority translates to market dominance. Google has the best AI research lab in the world. They invented the Transformer architecture. They have more TPUs than anyone. And yet, developers are choosing DeepSeek over Gemini.
Why? Because Google's developer experience is terrible. Their API pricing is opaque. Their model iteration cycle is unpredictable. Their tooling is fragmented across multiple product lines. Developers don't have time to navigate that complexity. They want a model that works, documented clearly, priced predictably.
This is the same lesson we learned in crypto. Having the best technology doesn't matter if you can't ship a usable product. Ethereum Classic had a technically superior vision. But it lost to Bitcoin because Bitcoin was simpler and more reliable. The market doesn't reward technical excellence. It rewards usability.
DeepSeek won because they made it easy. Clear API documentation. Competitive pricing. Consistent performance. They treated developers as customers, not research subjects. That's a lesson Google's AI division needs to learn before it's too late.
The Takeaway: Watch the Value Density Metric
The next 12 months will determine whether this is a permanent restructuring or a temporary blip. The metric to watch isn't token share. It's value density. How much economic value does each token create? Closed-source models currently dominate this metric. But that dominance is fragile.
If open-source models close the gap on complex reasoning tasks, the value distribution will shift. And when it shifts, it will shift fast. The infrastructure is already in place. The developer habits are already formed. The only question is whether the open-source community can deliver the next generation of capability improvements.
I've been in this game long enough to know that consensus is fragile until it becomes irreversible. The 62% token share is a warning shot. But it's not a victory. The closed-source vendors still control the high-value tasks. They still command the premium pricing. They still have the enterprise relationships.
The question is whether they can maintain that position while open source eats their lunch from below. Speed is the only hedge in a zero-latency market. And right now, open source is moving faster. Volatility is the price of admission, not the exit. The next move belongs to whoever can adapt to this new reality first.
The ledger does not lie. The question is whether the market is ready to read it.
