AI Model Experiment · August 2026

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

14 months as a Google fanboy. 185,172 production requests. $2,129 of my inference spend. Here's what changed.

Austin Starks · August 8, 2026 · Founder, NexusTrade · 16 min read

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.

Robinhood Alphabet Class A history showing a GOOGL call debit spread closed for $5,240 alongside its two legs — Long the $300 call for $3,640 on March 25. Short the $400 call for $2,230 on April 28. A $1,410 net debit, closed August 7 for $5,240.

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

Two years of Google, against just holding it

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.

AS What were the trailing P/E ratios for TSLA and GOOGL on 2025-05-21?

Ticker	Date	Price	TTM EPS	P/E
GOOGL	2025-05-21	$168.56	$9.01	18.46
TSLA	2025-05-21	$334.62	$1.98	169.17

View the SQL it wrote

WITH TargetDate AS ( SELECT '2025-05-21'::DATE AS target_d ), ActualDates AS ( SELECT ticker, MAX(date::DATE) AS actual_d FROM lake.sec_daily_ohlc CROSS JOIN TargetDate WHERE ticker IN ('TSLA', 'GOOGL') AND date::DATE <= target_d GROUP BY ticker ), TTM_EPS AS ( SELECT q.ticker, SUM(q.netIncome) / NULLIF(MAX(q.commonStockSharesOutstanding), 0) AS ttm_eps FROM ( SELECT ticker, netIncome, commonStockSharesOutstanding, ROW_NUMBER() OVER (PARTITION BY ticker ORDER BY date DESC) AS rn FROM lake.canonical_quarterly_financials CROSS JOIN TargetDate WHERE date::DATE <= target_d AND netIncome IS NOT NULL ) q WHERE q.rn <= 4 GROUP BY q.ticker HAVING COUNT(*) = 4 ) SELECT p.ticker, p.date::DATE AS date, CAST(p.closingPrice AS DOUBLE) AS price, CAST(t.ttm_eps AS DOUBLE) AS ttm_eps, CAST(p.peRatioTTM AS DOUBLE) AS pe_ratio FROM lake.sec_daily_ohlc p JOIN ActualDates ad ON p.ticker = ad.ticker AND p.date::DATE = ad.actual_d LEFT JOIN TTM_EPS t ON p.ticker = t.ticker

NEXUSTRADE STOCK SCREENER · POINT-IN-TIME READ TTM EPS FROM 4 TRAILING SEC QUARTERS

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.

NexusGenAI AI Metrics dashboard showing $2,129.42 spend across 185,172 requests in 30 days — Canonical article window, trailing 30 days ending 2026-08-07. 185,172 requests, $2,129.42, 7,581.8M tokens, 11.96s average latency, 99.3% success.

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.

A real Aurora run: one prompt in, 20 ReAct iterations, a backtested strategy out — A real Aurora run. One prompt in, 20 ReAct iterations, a backtested strategy out. No human in the loop. This is the loop every number in this article is measured against.

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.

Harness	What it grades	Corpus
Plan replay	Router V5 planning decisions	29 frozen production conversations
Next-action replay	Agent V6 next action in a ReAct loop	69 frozen decisions x 3 samples
Sandbox bake-off	Sandbox codegen, end to end on Modal	5 models on one prompt set, real VMs
Grader vs labels	The grader itself, map and reduce stages	23 hand-labelled artifacts, 14 task types
Screener bake-off	Natural language to DuckDB SQL	22 questions, direct EvaluateGPT descendant

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.

Calibrate against hand labels. The next-action judge agrees with human labels on 39 of 40 cases, 97.5%, against an 80% gate.
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.
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.
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.

Open the 65-PDF Pelosi fixture and five other real grader jobs

Here's what that job actually is.

A human opens the House Clerk's disclosure search, picks a year, downloads that year's FD.zip index, finds Pelosi's filings in it, opens each PDF, reads the transaction table, and types the rows into a spreadsheet. Ticker, buy or sell, amount, date. Sixty-five documents, and plenty of them are scans rather than text.

Now write those steps down and hand them to an intern. That's the easy version. I had to teach a computer to do it.

So the agent rents a machine, writes Python, pulls the archive, resolves every document URL, downloads all 65 PDFs, runs OCR on the scanned ones, parses the tables, and emits rows.

It can go wrong at every one of those steps.

A date regex anchored on MM/DD/YYYY silently drops six rows, because some filings print 02/2/2018. A model reads "extract ticker, type, amount" as a filter and throws away every holding whose ticker the filing doesn't spell out, losing AllianceBernstein Holding L.P. even though it trades as AB. A sliding-window regex matches fragments across line breaks and reports 19 transactions in a filing that contains 10. Skip the transaction-type filter and a Disney sale comes back as a purchase.

Every one of those produces a JSONL file full of plausible rows. That's the whole problem. The output always looks fine.

So the question isn't whether the code ran. It's whether the agent controlled the computer well, and you can't answer that by reading the answer. You have to already know what the answer was.

For Pelosi I do. 135 transactions, read by eye off the rendered PDFs, independent of any extractor.

But Pelosi is one task, and the grader doesn't get to specialize. These are all real jobs Run Compute has been pointed at:

Train a PPO reinforcement-learning policy on NVDA daily bars, hold out 2024, and emit a long/flat signal for every out-of-sample session. No lookahead, features standardized on train-only statistics.
Pull every customer representing 10% or more of revenue out of the latest 10-K for eight mega-caps, and record an explicit statement where a company discloses none.
Test whether an unusually delayed quarterly filing predicts forward returns across US non-financials, 2019 through 2025, using filing-aware fundamentals so the delay is measured against the fiscal period rather than the publish date.
Reconcile disclosed share-repurchase authorizations against what twelve companies actually bought back, straight out of their 10-Ks.
Measure whether Reddit sentiment predicts returns at t+7, and whether the effect survives once you lag it properly.

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.

Grader architecture, and how it scored

Final judgment call. Every model saw the same mapper findings.

3 models · 23 tests · $0.10

Model	Defects found	Same grade on re-run
GPT 5.6 Luna	83.1%	19 of 23
Hy3	83.1%	18 of 23
MiniMax M3	82.5%	16 of 23

One artifact. A filing and the agent run that acted on it. No single call holds it. Split it into representations that can each be read on their own. Map. Four cheap calls at once, each scored on one question: did it notice? Reduce. Nine findings fold into one expensive call. Judgment gets paid for once. Three dropped as noise, six upheld. One verdict, one letter grade. Nothing a mapper missed was ever in the fold.

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.

The rows that should matter to me	Luna	GPT 5.6 Sol	GPT-5.5	Best Claude
Big Finance Bench	36%	53%	49%	44%
Long context, 8-needle 256K-512K	41.3%	91.5%	81.5%	n/a
Toolathlon (tool use)	53.4%	58.0%	55.6%	61.7%
SWE-Bench Pro	62.7%	64.6%	59.4%	80.3%
Agents' Last Exam	50.3%	52.7%	46.9%	45.2%

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.

Benchmark	Field	Winner	The margin
Planning	16 models, 29 conversations	GPT 5.6 Luna	Within one standard error of the top score at $0.0012 a decision, the cheapest in the field
Execution	23 models, 69 decisions x 3	GPT 5.6 Luna	89.2, and the only model to beat the old default on score, cost, latency and schema at once
Artifact grading	23 labeled artifacts, map then reduce	GPT 5.6 Luna	83.1% of defects found, grade stuck on 19 of 23 re-runs. MiniMax stays the fallback
Sandbox codegen	5 models, one task, real Modal VMs	GPT 5.6 Luna	Top grade, fastest, cheapest — simultaneously. DeepSeek took 3x the wall clock and 2x the cost to never get there
Stock screening	22 questions to DuckDB SQL	Gemini 3.6 Flash	Beat Luna by 29 points of average score. Google keeps this one

Planning · 16 models · Luna is within one SE of the top score at 1/263rd of Opus

Planning: 16 models, 29 frozen production conversations

Router V5 reads a request and decides what to do: write a plan, dispatch to a catalog tool, ask a clarifying question, or continue an existing agent. I froze 29 real conversations, hand-labelled them, and replayed every model through the identical corpus.

Model	Score	+/- SE	$ / decision	p50
meta/muse-spark-1.1	0.759	0.079	$0.0229	9.6s
openai/gpt-5.6-luna	0.731	0.068	$0.0012	8.6s
openai/gpt-5.6-luna-pro	0.731	0.068	$0.0076	21.9s
moonshotai/kimi-k3	0.731	0.068	$0.0799	38.9s
x-ai/grok-4.5	0.724	0.065	$0.0519	23.5s
deepseek/deepseek-v4-pro	0.710	0.064	$0.0142	27.2s
google/gemini-3.6-flash	0.662	0.070	$0.0387	8.5s
anthropic/claude-opus-5	0.662	0.074	$0.3159	26.6s
openai/gpt-5.6-terra-pro	0.634	0.073	$0.0646	16.0s
google/gemini-3.1-flash-lite	0.586	0.066	$0.0031	1.8s
anthropic/claude-sonnet-5	0.579	0.071	$0.1348	24.9s
z-ai/glm-5.2	0.515	0.079	$0.0246	44.8s
deepseek/deepseek-v4-flash	0.493	0.080	$0.0032	12.4s
qwen/qwen3.8-max	0.400	0.082	$0.0421	168.7s

Showing 14 of the 16 arms. Both poolside models are cut for space; they finished last at 0.496 and 0.446.

Muse Spark posted the highest raw score in the field at 0.759, above Luna and above anything Anthropic or Google shipped. It's Meta's, where my twin brother Justin Starks is a senior software engineer.

Good news, Justin. That six-figure stock vest might be worth something one day.

It still isn't my default. 0.028 of score is not worth paying nineteen times more per decision, and I'd have told him the same thing.

Opus 5 costs 263 times what Luna costs and doesn't score better. They tie on 17 of the 29 fixtures and split 7 to 5 on the rest. A paired t-test puts that difference at t = +0.85, which is nothing.

Against Sonnet 5, Luna wins by +0.152 at t = +2.11. That one is real.

Ten of the sixteen models are dominated outright: something else beat them on cost and latency and score at the same time. Both Anthropic models are on that list.

Execution · 23 models · Luna is the only one that beat the old default on every axis

Execution: 23 models, 69 frozen decisions, 3 samples each

The planner writes the plan. The executor lives inside the ReAct loop and picks the next action, over and over, until the job is done. This is where an agent actually spends your money.

The swap that shipped · 2026-08-06

deepseek-v4-flash (old default)

75.3

$6.23 / 1k · 17.9s p50 · 98.1% schema

gpt-5.6-luna (new default)

89.2

$1.67 / 1k · 5.6s p50 · 99.0% schema

Luna is the only model of 23 that beat the previous default on every axis at once. It also outscores Muse Spark 1.2, the priciest model I tested, at one twenty-sixth of the cost.

Model	Mean score	Schema valid	$ / 1k decisions	Prod p50
openai/gpt-5.6-luna-pro	91.7	100.0%	$25.05	9.9s
openai/gpt-5.6-luna	89.2	99.0%	$1.67	5.6s
meta/muse-spark-1.2	86.1	99.5%	$44.23	7.2s
x-ai/grok-build-0.1	84.7	100.0%	$26.88	15.4s
google/gemini-3-flash-preview	83.3	97.1%	$24.95	6.7s
z-ai/glm-5.2	82.4	98.1%	$25.37	15.7s
google/gemini-3.6-flash	80.1	100.0%	$24.21	7.7s
deepseek/deepseek-v4-flash	75.3	98.1%	$6.23	17.9s
mistralai/mistral-small-2603	73.0	97.6%	$1.00	6.3s
google/gemini-3.5-flash-lite	72.3	99.0%	$7.17	2.0s
nvidia/nemotron-3-ultra-550b	57.1	77.5%	$35.28	n/a
poolside/laguna-xs-2.1	51.1	66.5%	$5.58	4.3s

Nemotron 3 Ultra is a 550-billion parameter model that charges $35.28 per thousand decisions and could only hold my output contract 77.5% of the time. Parameter count bought nothing.

That's the migration I ran the same day.

Artifact grading · 23 fixtures · Luna wins the final judgment call on consistency

Artifact grading: same mapper findings, swap only the judge

Four cheap mappers propose defects. One reducer decides which ones are real and emits the letter grade. For this bake-off every model saw the exact same mapper findings, so the score measures judgment, not discovery.

Model	Defects found	Same grade on re-run
openai/gpt-5.6-luna	83.1%	19 of 23
tencent/hy3	83.1%	18 of 23
minimax/minimax-m3	82.5%	16 of 23

Luna tied Hy3 on finding defects, then won on consistency. Re-running the same test, its grade stuck more often, and it raised fewer false alarms than MiniMax. MiniMax stays the fallback.

Sandbox codegen · 5 models, same task · Luna wins on grade, wall clock and cost simultaneously

Sandbox codegen: end to end on real Modal VMs

The sandbox operator writes code, runs it, reads its own artifacts, and keeps iterating through a remediation loop until the work clears review. Same prompt, same planner, same grader, real machines. Every model below ran the identical task: correlate Strait of Hormuz ship traffic against the next USO trading session.

Model	Grade trajectory	Wall	Cost
openai/gpt-5.6-luna	D → B+ → D → B+ → D → B+	59m	$2.63
z-ai/glm-5.2	D → D → B+ → D → D → D	91m	$2.72
qwen/qwen3.7-flash	D → D → D	124m	$2.85
deepseek/deepseek-v4-flash	D → D → D → D → D → D	181m	$5.17
google/gemini-3.5-flash-lite	D, then failed out	24m	—

Luna is the only model that is best, fastest and cheapest at the same time. It reached the top grade in the field three separate times; GLM managed it once, and neither Qwen nor DeepSeek got there at all. DeepSeek is the mirror image of Luna: slowest, most expensive, never left the bottom band.

What the oscillation told me

This ran on an early build of the remediation loop, and the sawtooth in Luna's trajectory is the interesting part. Grades climb and fall back instead of ratcheting.

So I labelled every blocking finding in the corpus by hand, 221 of them. Sixteen percent were arithmetic contradictions in the delivered numbers. Sixty percent were defects in code the agent wrote to check its own work — an audit script that assigned the same variable into both delivered_stats and recomputed and then hard-coded a match, acceptance fields written as a literal True, a reconciliation reporting "dedup_rows_removed": 2 against 18 rows in and 17 out.

Each pass fixed the finding it was handed and wrote a fresh self-check with a new hole in it, which is exactly what a sawtooth looks like. The fix isn't a better prompt or a bigger model. It's to compute those identities host-side, so the agent has no field to assert them in and nothing to get wrong. That work is underway; the table above is the before.

One cell per model on one task, so read the ordering as directional. Wall clock is soft: my own web tier was CPU-throttled for part of this run, which inflated latency unevenly across arms. Grade trajectories and costs come from the durable grade audit and provider billing.

Stock screening · 22 questions · Gemini 3.6 Flash wins, by 29 points

Stock screening: Google wins this one outright

This is the direct descendant of EvaluateGPT. Twenty-two natural language questions, each turned into DuckDB SQL, executed against my real lake, and scored on whether the answer was actually correct.

Model	Average score	Median	Success rate	Avg execution
google/gemini-3.6-flash	0.841	1.00	86.4%	26.6s
google/gemini-3-flash-preview	0.791	1.00	81.8%	18.9s
google/gemini-3.5-flash	0.727	1.00	72.7%	33.3s
google/gemini-3.5-flash-lite	0.664	0.90	72.7%	19.4s
openai/gpt-5-mini	0.664	1.00	68.2%	41.5s
openai/gpt-5.6-luna	0.550	0.75	59.1%	27.0s

Gemini 3.6 Flash beat Luna by 29 points of average score and 27 points of success rate, on the exact task I built EvaluateGPT to measure. It's not close and I'm not going to soften it. Production runs the model that won.

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.

Model	Judged by luna-pro	Judged by gemini	Delta
gpt-5.6-luna	89.2	92.4	+3.2
gemini-3-flash-preview	83.3	94.1	+10.8
deepseek-v4-flash	75.3	90.9	+15.6
muse-spark-1.2	86.1	91.8	+5.7

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.

Job	Model
Agent execution, every ReAct decision	GPT 5.6 Luna
Sandbox codegen	GPT 5.6 Luna
Portfolio generation	GPT 5.6 Luna
Artifact grading	GPT 5.6 Luna
Sweep gene authoring	GPT 5.6 Luna
Sandbox gateway calls	GPT 5.6 Luna
Standard chat	GPT 5.6 Luna
Stock screening	Gemini 3.6 Flash
Insight relevance	Gemini 3.6 Flash
Web search and news synthesis	Muse Spark 1.2 (experimental)
Social mention discovery	Grok 4.5
Anthropic	nothing
DeepSeek	nothing

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.

Workload	Codegen	OCR	Compute	Grading	All in	Wall
pelosi (65 PDFs)	$0.91	$0.83	$0.0015	$0.42	$2.16	18 min
fundamentals OOS report	$0.44	n/a	$0.0010	$0.65	$1.10	n/a
hormuz research report	$0.50	n/a	$0.0010	$0.42	$0.93	14 min
nvda average close	$0.16	n/a	$0.0006	$0.25	$0.40	4 min
python hello world	$0.12	n/a	$0.0006	$0.23	$0.35	3 min

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.

Window	Calls	Total spend	Google	Google share
Before: Aug 5, 2 PM to Aug 6, 2 PM	15,392	$150.62	$35.75	23.7%
After: Aug 7, 2 PM to Aug 8, 2 PM	7,373	$28.36 projected	$1.15 projected	4.0%
Thirty-day run rate at the new mix	n/a	$851	$34	4.0%

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.

GOOGL	2025-05-21, I published	2026-08-06, migration day
Price	$168.56	$357.75
P/E, trailing	18.46	17.92
TTM revenue	$359.7B	$445.9B
Revenue growth, YoY	13.1%	20.1%
TTM net income	$111.0B	$244.2B
Net income growth, YoY	34.7%	111.3%

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.

Build a strategy with the deployment winner

Same agent, same data lake, same GPT 5.6 Luna measured in these five harnesses. Free to start, no card, no code.

Start free at nexustrade.io

Build the strategy this article describes

Create a free account to backtest ideas against market history, inspect the risk, and deploy to paper or live markets when you're ready.

Free to browse. No credit card required.

Discussion

No comments yet.