I Have a Quote for a $148,497 AI Desktop. That Is Not the Expensive Part.

For the past nine days I’ve been running one of the more ambitious Layer2C Labs experiments yet. I’m trying to quantify cost per solved task. Not cost per token, not cost per million tokens, not GPU utilization. A solved task. That’s a number a business can actually do something with.

The original idea was simple enough. Run the same workload against hosted infrastructure and against the two DGX Sparks in my lab and figure out what each token actually buys me. Do that well and I should eventually be able to answer a question I get asked a lot: is a Dell Pro Max with an NVIDIA GB300 actually worth it?

I have a real number for that machine, because I asked. Dell quoted me $148,497.24 on August 14 for a Pro Max FCT6263: a GB300 Grace Blackwell Ultra superchip, 496GB of LPDDR5X system memory, 252GB of HBM3e on the GPU, 16TB of NVMe. With tax it lands at $162,678.26. That’s the sticker everyone fixates on, mine included.

The problem is that the deeper I got into the experiment, the more incomplete the original model started to look.

The cost I’d been ignoring

To test the theory, I’ve had to fine-tune a series of models. That’s where the plan started to wobble, because it exposed a cost I had minimized in my original thinking: the cost of creating the model in the first place.

Here’s what that cost looks like when you actually write it down. I trained three fine-tunes of Gemma 4 and threw all three away. One learned the wrong dialect of tool calling. One learned the right dialect and still couldn’t land an edit. One trained a skill the base model already had, which I’d have known if I’d measured the base first. Then I pulled a community fine-tune off the shelf, Agentica’s DeepSWE-Preview, and tested it four different ways before accepting it only works inside the harness it was trained in.

The ledger for that path: about $58 in rented GPU time, roughly 74 hours of GPU time on hardware I own, six of the nine days, and zero additional solved tasks. Meanwhile OpenAI’s GPT-5.4 mini solved all 22 tasks for $3.14 in 40 minutes. Every solved task I’ve produced so far came from a model I didn’t train.

We talk about AI economics as if the model simply appears. It doesn’t. You build datasets. You run a fine-tune. You evaluate it, and the result isn’t good enough, so you change the data and run it again. You throw models away. The infrastructure consumed by all of those failed attempts didn’t disappear just because the models did.

That cost belongs somewhere.

If it’s a factory, bill it like one

This is where the experiment connects back to my AI Factory Economics work for CIOs. A factory doesn’t calculate the cost of a finished product based only on the electricity consumed during final assembly. It includes tooling, scrap, yield, failed production runs, and labor. AI shouldn’t be any different.

The lab made the scrap rate literal this week. To build a training set for the one tune that might work, I’m generating about 330 candidate solutions and keeping the ones that pass the test gate. The keep rate is running at roughly one in five. That’s yield. The other 80 percent is scrap, and the GPU hours it consumed are on the bill.

The industry has centered its economic discussion on inference. What does a million tokens cost? That’s useful, but it isn’t Cost of Goods Sold (CoGS). A more realistic model looks like this:

AI CoGS = inference
        + training and fine-tuning
        + evaluation
        + experimentation
        + data
        + platform operations
        + human intervention

Then you divide by something the business cares about:

Cost per solved task = total AI production cost / successfully completed tasks

Cloud versus the box in my lab

Cloud gives me elasticity. $36 of that $58 was a pair of MI300X cards I rented for six hours this week, and when I realized I’d pointed them at the wrong experiment, I tore them down and ate the bill. Scrap, priced and closed. Local infrastructure has the opposite profile. The Sparks ran the same 22 tasks to completion with local models only, for zero metered dollars, though the hours of depreciation and power behind that zero are a bill I’ll price in the final ledger. The marginal experiment costs me nothing but patience.

So the important comparison isn’t hosted token versus local token. It’s what each architecture costs me to produce, and then continuously improve, a successful unit of work. If I have to train eight models to discover the ninth one is useful, the cost of the winning model includes the other eight. A platform that makes experimentation cheap can be economically superior even if its individual inference token is more expensive.

What this lab is actually a proxy for

I’m not really pricing one desktop. I’m pricing whether owning a model is worth what it costs to own one, because that’s the decision sitting behind the hardware question.

Earlier labs said the opportunity is real. In Lab 012, letting a free local model triage and escalating only the five repairs it missed cost $1.12, against $13.79 for pushing all 22 through a frontier model, for output a validator scored identical. That’s a twelvefold gap on capacity I already own. Lab 002 is where I started arguing you should own the weights. Findings like those are why I keep spending nine-day stretches on this.

Now the elephant, and I’d rather name it than route around it. Foundation models are very good and getting better, including inside the narrow domains where a fine-tune used to be the obvious answer. That’s not a hedge, it’s the thing my own ledger keeps demonstrating. My $58 of scrap bought nothing this week in part because GPT-5.4 mini was already good enough at the task I was trying to teach a smaller model to do. Every month that keeps being true, the payback window on a custom model gets shorter.

This lab doesn’t settle that. It prices one side of it honestly, which is more than the discussion usually gets. The question of whether the frontier simply outruns the economics of owning a model is a different lab, and I don’t have it yet.

Tokens are an infrastructure number

Tokens are an infrastructure measurement. Solved tasks are a business measurement. The CIO doesn’t care how many tokens the factory produced. The CIO cares what it cost the factory to produce something useful.

The lab isn’t finished. The one tune left standing has a bar to clear, nine of 22 tasks, and 15 to 25 GPU hours of training ahead of it before I know. Whatever it scores, its cost per solved task gets computed against the whole ledger, not against its own training run.

Which is why the $148,497 is the easy number. It arrives on a quote, with a date on it, and you can put it in a capital request. The expensive part is everything that quote doesn’t show: the datasets, the failed runs, the scrap, the models that taught me something and produced nothing. So here’s what I’d put to any CIO budgeting a fine-tuning line item. Have you priced the models you’re going to throw away?