I turned $5,199 into $21,935 betting on Google. Then OpenAI took over my trading platform. I sold every call.

I've been a Google fanboy for over 14 months.

The proof is here. In May 2025 I laid out exactly why I liked them. The self-driving cars and the fundamentals were a start, but what I really loved was that Google dominated one category alone: the best, most cost-efficient language models for production deployments.

On August 7, I realized that's no longer true.

So I sold all of my Google calls.

That was the last piece of a two-year position.

Green is my book. The two flatter lines are the same $5,199 put into GOOGL shares and into SPY on the same first day and left alone. Trading it returned 322%. Owning shares returned 112%. SPY returned 42%.

Looking at what drew me to Google, I no longer see another 100% return on the horizon. The company may keep compounding, but the specific model-cost advantage I bought has narrowed.

That does not erase the rest of the Google thesis. But one of its most important asymmetries, frontier model quality at bargain production pricing, is no longer unique to Google. Here's what has changed in the past year.

A year ago

Why I was obsessed with Google

When I published that article last year, I liked Google for a few very specific reasons.

Their technology was unbeatable throughout the stack. AlphaFold solved one of the world's hardest biological problems. Their AI models were cheaper than OpenAI's and Anthropic's while performing better. And the little things, like their "other bets", were going strong.

As a concrete example, you can't step outside in Austin, TX without seeing their fleet of Waymos. They were crushing the self-driving narrative while their nearest competitor, Tesla traded at a 169 P/E.

Google's was 18.

It wrote the SQL itself, walked back to the last session on or before that date, and summed four trailing quarters of SEC-filed net income for the EPS.

A company priced like a dying consumer staple, expected to grow like a Y Combinator startup, and that controlled the best AI models the average person could afford. That was the whole thesis.

So I bought the calls. And I powered my entire platform with Google's models for a year.

It worked... for a while.

Then Google's models got old.

Specialized models picked up individual jobs along the way.

DeepSeek V4 Flash, at $0.14 per million input tokens and $0.28 per million output tokens, powered the orchestration layer that used to cost me hundreds of dollars per month. Grok 4.5 powered my search... not only across X, but ALL of the web.

But the core of my platform had been running on the same assumptions for twelve months: "Google was the best, so use it everywhere."

I hadn't re-evaluated this assumption in a year. As I prepare for a major launch into the institutional space, I knew I needed to.

So here's what I did.

Across the past 30 days I rebuilt the evaluation layer of my platform. I built the orchestration loops that turn Nancy Pelosi's public filings into a testable trading signal. I launched scheduled agents that watch the market around the clock. And I benchmarked every half-decent large language model on OpenRouter, on my own jobs, against my own data.

The canonical window for this article is the trailing 30 days ending August 7: 185,172 production requests and $2,129.42 of total inference spend. That includes the benchmark runs and every other production call in the window.

I expected to find unique winners for each individual task. DeepSeek could power my orchestration loop, Gemini could control querying, and OpenAI could handle planning. That has been the status quo for a long time now.

That has changed. Most of the high-volume agent loop now routes to one provider.

On planning and execution, the two high-volume jobs, GPT 5.6 Luna scored at the top while costing a fraction as much. It was the only executor that beat the old default on score, cost, latency, and schema validity at the same time.

So I already acted on it. On August 6th I removed model selection from my AI platform entirely. Every ReAct decision and sandbox code-generation call now routes through the model I choose. The smallest jobs, like stock screening, keep their own benchmark winner.

The numbers made the choice, and I stopped charging users for a worse option.

Here is why Luna won the deployment decision: quality rose to the top of my benchmarks at a fraction of the incumbent's price.

Methodology

How to properly evaluate an AI trading bot

When evaluating these models, I had to answer a deceptively difficult question. How do I "grade" my AI model's performance?

It really depended on the task at hand.

My AI trading bots fetch live data, write strategies, run backtests against a 10.3 billion rows market data lake, read their own results, rent virtual machines, write Python, read the traceback, fix the bug, and deploy trading strategies. A single run spans 30 to 50 model calls and can take 40 minutes or longer.

So "which model is best" isn't one question for me. It's a dozen. A model that writes a beautiful plan can be useless at picking the next tool call. A model that nails document extraction can stall out in an agentic loop.

I built a separate harness for each job that matters.

Execution-harness context bound: the next-action replay covered 73,397 to 83,363 input tokens per decision. Its tested ceiling was 83,363 tokens, not the 256K-to-512K regime in the public long-context benchmark.

All per-decision cost figures use provider billing, not list price multiplied by total context. The replays reused long prompt prefixes, so prompt-cache discounts account for the gap. The harness retained total input tokens and provider-reported cost, but not the cached-token split.

Two years ago I open-sourced EvaluateGPT, a framework that asks a model to write SQL against a real financial database, executes it, and has a panel of LLM judges score the answer. I expanded that framework to every layer of my platform, from generating trading strategies to controlling a computational engine.

This was much harder than it sounds.

The judges had to pass their own exam first

A trading agent's answer isn't multiple choice. It's a plan, a tool call, a 40-page PDF extraction. So every judge here had to clear a gate before it was allowed to grade anything.

1. Calibrate against hand labels. The next-action judge agrees with human labels on 39 of 40 cases, 97.5%, against an 80% gate.
2. Take the median of N draws. At temperature zero, 4 cases by 3 repeats moved 2 of 4 by a full scoring band. Median-of-3 lifted agreement from 85.7% to 92.9% with no rubric change.
3. Re-grade across model families. 827 already-replayed rows re-scored by a judge from a different vendor, purely to measure how much of the result was my judge's taste.
4. Separate judge noise from the decision. Top planner scores sat within roughly one standard error. Those scores do not choose the model. Billing, latency, and hard schema checks do.

The planning bakeoff made the choice clear. The best models scored almost the same. Luna cost much less. That was enough to migrate. Opus costs 263 times more and does not score better.

Then I had to grade the grader

The hardest thing to grade on this platform is a Run Compute task, where the agent rents a machine, writes its own Python, and hands back a dataset. So before I trusted a single letter grade, I built a corpus to test the grader itself.

Every one of those produces a different artifact, fails in a different way, and has a different definition of correct. I can't hand-read ground truth for a task somebody invents tomorrow.

So the grader has to be a generalist, and it had to be tested like one.

Naively, the grader is simple. Use an LLM with a 1 million token context window, attach all of the code snippets, run logs, and documents, and ask the model to grade how well it did.

Reality doesn't work that way.

Take Pelosi as the example. An off-by-one in a reported sample count. A holding that went stale three quarters ago. A membership date that resolves to the wrong quarter. Now go find those inside a generated Python program, the rows it produced, and a validation log. On the Pelosi run, 65 PDFs on top of that.

A single monolithic grading call failed badly in my tests. It could not reliably find small defects across the code, rows, logs, and 65 PDFs at once.

For the first time in months, vibe coding a solution didn't work. I thought to engage my brain and think of a better solution.

I came across "map reduce". I decided to give it a try.

Luna tied Hy3 on finding defects, then won on consistency. Re-running the same test, its grade stuck 19 times out of 23. MiniMax flipped more often and raised more false alarms. Luna also cost a fraction as much. MiniMax remains the fallback.

One asymmetry forces that shape. A defect no mapper names can never be recovered downstream, because the reducer only adjudicates what it was handed. A miss at the map step is permanent.

Because there are so many API calls, the mappers have to be dirt cheap. By making each model look at a small subset of the solution space, and then combining the results, we can get a scarily good assessment of the overall quality of the solution, for a cost that's less than a single Fable 5 API call.

Now that you see the effort it was to grade a model for a single task, I had to grade several models for distinct tasks. While it used to be the case that I'd use DeepSeek for this and Google for that, almost all of my LLM tasks are now routed to one API.

The verdict

Luna won the deployment decision, not every benchmark.

Public benchmarks make Luna look mediocre. The July 9 launch table puts Luna at 84.7% on Terminal-Bench 2.1, 62.7% on SWE-Bench Pro, and 50.3% on Agents' Last Exam, at $1 per million input tokens and $6 per million out, (cut to $0.20 and $1.20 three weeks later).

Luna leads nothing on that table. It trails OpenAI's own flagship everywhere, Claude beats it on SWE-Bench Pro by 17.6 points, and on Terminal-Bench it scores below the model it replaced. The only column it wins is price.

And it gets worse when you look at the rows closest to what I actually do.

That test measures monolithic retrieval from a massive prompt; my production stack handles long inputs through bounded agent decisions and map-reduce.

Public benchmarks did not predict my production results. Taken at face value, those tables would have told me Luna was not worth testing. They would have screened out the model that won my production bakeoff before the bakeoff started.

Published benchmarks measure a model against a test somebody else wrote. Here are three I wrote, on my data, with judges I calibrated and prices from provider billing.

The five that decided it

Four went to OpenAI. One went to Google.

Five harnesses ran. Every one of them is on the board. Open a row if you want the table it came from.

The judges were biased too

Then I did the thing most benchmark posts skip. I took 827 rows that were already replayed and re-graded them with a judge from a completely different vendor, to find out how much of my result was my judge's taste.

Both judges prefer their own family. The Luna over DeepSeek gap collapses from +13.9 to +1.5 depending on who's grading.

Luna is the one model both judges agree about: 3.2 points of cross-judge disagreement against DeepSeek's 15.6. Output that's actually good scores the same no matter who grades it. Output that suits one grader's taste doesn't.

The deployment decision never rested on that score alone. Cost is provider billing. Latency is provider timestamps. Schema validity is a deterministic key check. On those three Luna beats the old default by 3.7x, 3.2x, and +0.9 points, and no judge touches any of them.

None of those tables proves that one model is universally smarter. Luna won four of the five harnesses, then separated itself on cost, latency, and schema discipline. Gemini won screening, where a user sits and waits and quality is visible in real time. Read together, the tables say the same thing: once several models clear the bar, engineering properties decide. That is a very different market from the one I bought Google calls for.

What I actually run

Luna runs almost everything now

Here is the production config, straight out of the constants file.

Seven of the eleven jobs listed are Luna, including every one that runs inside the agent loop. Google keeps screening, where it beat Luna by 29 points, plus relevance ranking and the top rung of the authoring-retry ladder, the model a failed generation escalates to rather than retrying itself. Meta's Muse Spark took web search and news synthesis, on a factual search bakeoff in July, and is running experimentally on 1.2. Grok holds the one job that needs several simultaneous live searches, finding a person's social posts about a ticker.

Anthropic and DeepSeek run nothing. Not a batch job, not a fallback. Neither is a default anywhere. Agent models are fixed by the platform now, so users cannot select either one.

What this actually bought me

A year ago, turning 65 congressional filings into a tradeable signal meant paying frontier prices for every attempt, and the attempts fail a lot.

A full research report, written by an agent that rented a virtual machine, pulled data from my lake, ran statistics on it, and had its own output graded, for ninety-three cents.

The sandbox compute is 0.2% of that. The machine is never the cost. And grading is roughly fixed per cell while codegen swings sixteen-fold, so there's a floor around $0.35 on any call, two thirds of which is the grader on a trivial one.

The conclusion

My LLM bill grew more than 5×. Google's projected share fell to 4%.

It used to be that Google was the only company that cared about people like me. Hobbyists and small businesses were being left out of the AI race because they couldn't afford to use the SOTA models for their tasks.

Google did not lose my dollars. Its billed revenue from me rose from about $342 to $841 as my workload grew more than fivefold. The signal is at the margin: of the $1,738 in new spend, Google captured about $500. The other 71% went elsewhere.

Window reconciliation: the headline and dashboard use the trailing 30 days ending August 7, $2,129.42 across 185,172 requests. This vendor chart uses the August 8 ledger cut, $2,146 across about 185,000 calls. The $408 figure is the prior-year comparison window shown here.

In the chart's prior-year comparison window, I spent $408 on inference and Google took 83.7% of it. They weren't a vendor, they were the supplier. Gemini 2.5 Flash and then 3 Flash were genuinely outstanding, and I built on them because nothing else was close on price per unit of intelligence. That was about $342 billed to Google.

In the August 8 vendor window, I spent $2,146. Google's share fell to 39.2%, but that was still about $841 billed to Google. Google more than doubled its dollars from me. It captured only 29 cents of each new dollar.

That's the whole story. Google kept the old work. It did not win most of the new work, on a platform where a year ago it was the only answer.

This is just the beginning

Most of the routing changes landed after the thirty-day window closed. In the last full day before the cutover, Google took 23.7% of my bill. In the first full day after it, Google's projected share fell to 4.0%. The 5% Anthropic slice in the chart is Claude traffic from before the Aug 6 cutover. At the new mix it is zero.

The part where I might be wrong

I sold my Google calls. Alphabet is still a strong company. If someone asked me for safe, long-term investments that will be around for decades, I'd still answer Google. The growth case I was underwriting with leveraged calls is no longer the one I want to press.

The stock doubled and got cheaper on earnings. Growth accelerated on both lines. My original thesis was "priced like a dying consumer staple, expected to grow like a Y Combinator startup," and by these numbers that thesis is more true today than the day I wrote it.

I'm not claiming Alphabet is in trouble. Search, Cloud, TPUs and YouTube do not care which model wins my ReAct loop, and the fundamentals say whatever they're doing is working.

I sold leveraged calls after a 112% run, with a 322% return on committed capital. When I bought them, Google had a unique opportunity with Gemini. Google executed, and the stock more than doubled. But the model-cost moat I could observe directly was no longer unique: Google captured only 29 cents of each new inference dollar while other providers took the high-volume loop. I banked the gain. I did not give up on the company.

Running NexusTrade gives me a firsthand view of technology shifts before they become obvious in an earnings report. That founder's view has shaped positions across my long-term investing account, including the wins and misses below.

Google's $2,146 of inference spend is immaterial to Alphabet, but the change inside my stack is a real signal: a product advantage I could measure every day had weakened. I combine signals like that with valuation and fundamentals, and over time that process has produced real trading gains.

Google can keep growing. Just not monstrously. It is safe and sound in my long-term investing account.

What that actually buys me

I can now run state-of-the-art for less than last year's cheapest model cost me.

A year ago this platform screened stocks, ran backtests and deployed trading strategies. That was the entire product. Today the same agent rents a virtual machine, writes its own Python on it, reads the traceback when it breaks, grades its own work before handing it back, and runs walk-forward optimization on options chains.

That's a categorically harder job, and it costs less than screening and backtesting did twelve months ago.

Which is why the model stopped being the hard part. Luna reasoned better where it mattered: it raised the executor score from 75.3 to 89.2, and it won the artifact-grading slot too. But reasoning alone did not make it the production winner. It also emitted valid schema 99% of the time, returned in 5.6 seconds, and cost $1.67 per thousand decisions. Compared to Gemini 3 Flash, the difference is night and day.

Expensive, heavy models just don't have a place in my business on these jobs. Other workloads will keep their own winners, the same way screening kept Gemini.