The $2,500 Desktop That Beat a $30,000 Workstation
A Forge-versus-Keystone review using the Flash Next model family, with and without Strata—and why the cheaper machine won.
Images were retouched for dust and clarity; a clear container was removed from the Forge image.
The Contenders
Two machines, running the same AI model family — Flash Next, with and without an enhancement layer called "Strata."
| Keystone | Forge | |
|---|---|---|
| AI model | Flash Next | Strata + Flash Next |
| Compression level ("quant") | Q4 | IQ3_S (smaller) |
| Video card | RTX 6000 Pro Blackwell, 96 GB | Tesla V100, 32 GB (from 2017) |
| Card's current street price | ~$20,000 | ~$800 (used) |
| CPU | Threadripper 9960 (Zen 5) | Ryzen 5700 (Zen 3, 8-core) |
| System RAM | 128 GB DDR5 | 64 GB DDR4 |
| Estimated hardware cost, before labor | ~$30,000 | ~$2,500 |
The headline figures above are hardware estimates only. They do not include labor, shipping, tax, licensing, ongoing support, or the original experimental research and development that produced the build process.
What the Build Labor Adds
Parts are only one part of a usable local-AI workstation. The following is an illustrative repeatable-build scenario, not recorded historical time, an invoice, a binding quote, or an established Delaney Solutions rate card. It uses the same estimating assumptions for both machines: $125 per hour for workstation hardware planning, assembly, and physical validation, and $200 per hour for specialist AI integration and tuning.
The hardware category covers parts planning and procurement, compatibility review, physical assembly, cooling and cable work, firmware checks, and hands-on physical validation. The AI category covers OS and driver preparation, Strata and model preparation, Hermes integration, hands-on inference and workload testing, troubleshooting, and documentation and handoff. The ranges avoid charging the same task twice and exclude unattended download, installation, and burn-in time.
| Repeatable labor estimate | Forge | Keystone |
|---|---|---|
| Workstation hardware labor | 6.5-13 hours at $125/hour $812.50-$1,625 | 12.5-23 hours at $125/hour $1,562.50-$2,875 |
| Specialist AI integration labor | 8.5-18 hours at $200/hour $1,700-$3,600 | 10-24 hours at $200/hour $2,000-$4,800 |
| Total estimated hands-on labor | 15-31 hours $2,512.50-$5,225 | 22.5-47 hours $3,562.50-$7,675 |
| Hardware-only estimate | ~$2,500 | ~$30,000 |
| Illustrative hardware-plus-labor total | ~$5,012.50-$7,725 | ~$33,562.50-$37,675 |
These rates are estimating assumptions chosen to keep routine workstation work separate from specialist AI systems work. For context, Micro Center advertises a $249.99 flat Express Pro Build that includes assembly, cable management, stability testing, drivers, and BIOS updates - useful evidence that ordinary PC assembly is not the same service as bespoke AI integration. Public specialist examples include $175-$275 per hour by labor category for AI and local-LLM consulting and $200 per hour for new AI automation builds. These are individual published examples, not a market average, equivalent quotes, or Delaney Solutions pricing.
The estimate above describes a repeatable customer build after the process is understood. The original model evaluation, Strata experimentation, integration design, benchmark design, and cross-system research are separate one-time R&D work. No reliable historical hours were recorded for that work, so it is acknowledged here but not assigned a speculative cost.
Keystone is about as good as a home AI setup gets right now. The Blackwell card alone costs more than most people's cars, and the Threadripper 9960 is a current-generation workstation chip. Forge is a seven-year-old datacenter graphics card - a retired professional model, bought secondhand for around $800 - bolted to a mid-range desktop.
Forge won, 8.9 to 8.6.
On hardware cost alone, that is a machine costing roughly one-twelfth as much beating the best consumer-grade AI workstation you can assemble today. Labor narrows the cost ratio because the hands-on integration work remains substantial on both systems.
First, in Plain English: What Is a "Quant"?
AI models are enormous piles of numbers. A full-size model can be hundreds of gigabytes. To fit one onto a video card, you compress those numbers — the same way you'd compress a photo to make the file smaller.
That compression level is called a quant. The number tells you how many bits are used to store each number in the model:
- Q4 — 4 bits per number. Good quality, moderate size.
- Q3 — 3 bits per number. Smaller, fits on less hardware — but supposed to be noticeably dumber.
Think of it like saving a photo as a high-quality JPEG versus a low-quality one. The low-quality version takes less space, but you lose detail. On paper, Q3 is inferior to Q4 — that is simply what the compression math says. Fewer bits, less precision, worse results.
Forge was running the smaller, supposedly inferior compression. Keystone was running the larger, supposedly superior one.
And Forge still won.
The "IQ3_S" label is a slightly smarter version of Q3 — it uses an "importance matrix" to decide which parts of the model deserve the extra precision. Think of it as a smarter photo compressor that keeps faces sharp while blurring the background. It helps, but it does not change the basic rule: Q3 is supposed to lose to Q4.
The Benchmark
Both machines got an identical prompt built around a made-up payment-processing system, with four tasks:
- Long-context retrieval — pull every constraint and error condition out of a dense technical brief into an evidence-backed table.
- Agentic coding — diagnose a duplicate-charge bug, write a fix, and design an API for a new refund service.
- Structured output — emit a strict JSON object with risks, rollback rules, and an API spec.
- Multimodal reasoning — reason about a hypothetical architecture diagram.
A fifth, unscored bonus prompt was included. Its premise was deliberately false.
Task by Task — The First Run
Long-Context Retrieval
| Keystone Q4 | Forge IQ3_S | |
|---|---|---|
| Rows extracted | 10 | 11 |
| Quote fidelity | Verbatim | Slightly paraphrased |
Both were accurate and invented nothing. Forge was more thorough; Keystone was more exact. Edge: Forge.
Agentic Coding — The Decisive Task
Both correctly spotted the root cause: a slow database write looked identical to a failed one, and without a duplicate-detection key, retries became duplicate charges. The fixes then diverged.
| Keystone Q4 | Forge IQ3_S | |
|---|---|---|
| Timeout set below retry trigger | ❌ | ✅ 450ms, under the 500ms trigger |
| Money stored as whole cents | ❌ | ✅ |
| Handles simultaneous retries | Implicit | ✅ Explicit |
| Audit written same-transaction | ✅ | ❌ |
| Audit readable by humans | ✅ | ❌ (hash only) |
Forge wrote the more defensive code — the kind of detail that separates a working payment system from one that loses money. Keystone wrote the safer audit trail — the kind that survives a regulator's review. Edge: split.
Structured Output
Forge produced the cleaner spec: header names only, and correct "greater than" symbols matching the source text's "exceeds" language. Keystone used looser formatting. Edge: Forge.
Multimodal Reasoning
Both caught the same subtle point — that a single ambiguous phrase in the brief could mean two very different system designs, and the diagram's arrow style would tell you which. Edge: tie.
Bonus — Catching a False Premise
The bonus prompt claimed a scheduling problem became impossible under certain conditions. It was not impossible. It was a trap.
- Keystone: did not attempt it.
- Forge: worked the problem, found the claim false, and said that a model which simply "explains the infeasibility is hallucinating compliance."
This is the behavior you want in an AI agent: check the premise, don't just comply with it. Edge: Forge.
The Scorecard
| Dimension | Keystone Q4 | Forge IQ3_S | Edge |
|---|---|---|---|
| Long-context retrieval | 8.5 | 9.0 | Forge |
| Agentic coding — code | 8.5 | 9.5 | Forge |
| Agentic coding — audit | 9.5 | 8.0 | Keystone |
| Structured output | 7.5 | 8.0 | Forge |
| Multimodal reasoning | 9.5 | 9.5 | Tie |
| Instruction adherence | 8.5 | 9.0 | Forge |
| Premise verification | not attempted | ✅ | Forge |
| Overall | 8.6 / 10 | 8.9 / 10 | Forge |
| Hardware-only cost estimate | ~$30,000 | ~$2,500 | — |
| Quality points per $1,000 of hardware cost | 0.29 | 3.56 | Forge ~12× |
Why This Result Is Remarkable
Three facts stack on top of each other, and each one makes the others more surprising.
1. Forge used the "worse" compression. Q3 is supposed to be inferior to Q4. This is not debatable — it is the basic tradeoff of model compression. A smaller model fits on smaller hardware and produces worse results. That is the deal. Forge broke the deal.
2. Forge ran on a video card from 2017. The V100 was a $10,000+ professional card in its day. Today it sells secondhand for around $800 because it lacks the newer hardware features — no BF16, no FP8, no modern tensor cores — that current cards use to accelerate AI work. Keystone's Blackwell card has all of them, plus three times the memory. On paper, this should not be close.
3. Forge's estimated hardware cost was about one-twelfth as much. Not one-twelfth less performance — one-twelfth the hardware price, with higher performance in the first comparison. Measured strictly against the hardware-only figures, Forge is roughly 12 times more efficient. That calculation does not include labor or one-time R&D.
For anyone building a local AI setup — a homelab, a small business, a research group on a budget — Forge's hardware value remains striking. The labor-inclusive scenario above also makes clear that turning parts into a stable, integrated AI system requires substantial specialist work.
The Other Surprise: Half the Power, Twice the Speed — On a Bigger Model
The quality score is only half the story. The power, heat, and speed numbers on the V100 tell a second one — and in some ways a more surprising one.
Here is the setup. Before this benchmark, the V100 was running Qwen 3.8 27B — a 27-billion-parameter model. For this benchmark, it was switched to Strata + Flash Next, which is a larger model, not a smaller one. Flash Next carries more parameters, more capability, and more of everything that normally makes an AI model heavier to run.
And yet the numbers went the other direction. Here is the before-and-after, in plain numbers:
| Qwen 3.8 27B (smaller model, before) | Strata + Flash Next (larger model, now) | Change | |
|---|---|---|---|
| Power draw during work | 200+ watts sustained | 50–130 watts | Roughly 2–4× less |
| Fan behavior | Ramped to full load (loud) | Barely ramps (near silent) | Dramatically quieter |
| Card temperature | 55–60°C sustained | Under 45°C | 10–15°C cooler |
| Speed (tokens/sec) | ~25 tok/s | 50–60 tok/s | 2× faster |
For readers who don't spend their days staring at hardware monitors, here is what those numbers actually mean:
Watts are electricity. A 200-watt draw is roughly like leaving two bright old-fashioned lightbulbs running full time. A 50–130-watt draw is like one to two bulbs — sometimes barely more than a phone charger's worth spread over time. The V100 went from working hard to working gently, and the electricity bill follows.
Fan ramp is effort you can hear. When a graphics card works hard, its fans spin up to full speed to dump the heat — and it sounds like a small vacuum cleaner. With the Strata + Flash setup, the fans barely spin up. The machine is quiet. You could sit next to it while it works and forget it's running.
Temperatures are heat, and heat is wear. Running a card at 55–60°C for hours is normal but not free — it ages the silicon and heats the room. Staying under 45°C is the difference between a card that's "working" and a card that's "idling with a purpose." The V100 with Strata is barely breaking a sweat.
Tokens per second (tok/s) is how fast the AI writes. A token is roughly three-quarters of a word. 25 tok/s is a comfortable reading pace — like a person typing steadily. 50–60 tok/s is faster than most people can read. The Strata + Flash setup isn't just cooler and quieter — it's more than twice as fast as the smaller 27B model it replaced.
So the full picture on the "cheap" box is this: it swapped in a larger model, doubled its speed, cut its power draw by half to three-quarters, dropped 10–15 degrees in temperature, and went from loud to nearly silent — while simultaneously winning the quality benchmark against a machine costing twelve times as much.
That is not a marginal efficiency gain. It is the kind of result that makes people question why they were running the smaller 27B model on old hardware in the first place. The answer, it turns out, is that they didn't need to. A well-tuned larger model stack did more work, faster, cooler, and quieter — and scored higher on the benchmark while doing it.
Where Keystone Still Won
One dimension, cleanly: transactional audit design.
Keystone wrote its audit record in the same database transaction as the money movement. That means no refund can ever exist without its audit trail — the two succeed or fail together. Forge wrote its audit record first, and stored an opaque hash instead of readable before-and-after values.
For a regulated ledger, that difference is real. Keystone's audit trail can be defended in a review. Forge's can be verified mathematically but not read by a human auditor. It is the one place the $30,000 machine earned its price.
Bottom Line
A desktop with roughly $2,500 in estimated hardware and an $800 secondhand video card scored 8.9 out of 10. A workstation with roughly $30,000 in estimated hardware and a $20,000 current-generation card scored 8.6.
Forge won five of seven scored dimensions. It produced more defensive code at a lower compression level — which the compression math says it should not have been able to do. It also did the one thing the expensive machine never attempted: it checked whether the question was honest, found it wasn't, and said so.
And it did all of this while running a larger model than before, drawing a fraction of the power, running 10–15 degrees cooler, keeping its fans near-silent, and generating text more than twice as fast as the smaller 27B model it replaced.
Keystone won exactly one dimension — audit design — and won it convincingly. That is the only place the twelve-times-more-expensive machine justified the difference.
The scoreboard reads 8.9 to 8.6. The hardware-only estimates read $2,500 to $30,000. On that hardware-only basis, the efficiency board reads roughly 12× in Forge's favor. And the power meter reads 50–130 watts instead of 200+ — while running a bigger model.
The most valuable behavior observed in the entire benchmark - the willingness to verify a premise instead of complying with it - appeared only on the cheap box, at the lower compression, on the older silicon, running cool and quiet.
The Strata-to-Keystone Turning Point: How the Pro 6000 Took the Crown
A chronological breakdown of the moment Strata was loaded onto Keystone, and why the result was a clean sweep rather than a narrow win.
Owner-reported follow-up, October 26, 2026. The scores and run observations below are Mike Delaney's benchmark results and were not independently reproduced for this article update.
The Timeline
| Step | Configuration | Score | What it showed |
|---|---|---|---|
| 1. First run | Keystone: Flash Next at Q4, no Strata | 8.6 | A strong baseline that lost to a cheaper box. |
| 2. First run | Forge: Strata + Flash Next at IQ3_S, V100 | 8.9 | Strata plus aggressive quantization beat a no-Strata, higher-precision run. |
| 3. The turning point | Keystone: Strata + Flash Next at IQ3_S | 9.3 | The same model and quantization as Forge, now on Keystone. |
The decisive moment came when the same Strata model was loaded onto Keystone and the benchmark was run again. That owner-reported run - Strata + Flash Next at IQ3_S on the RTX PRO 6000 Blackwell - scored 9.3 out of 10, the highest score in the benchmark.
What Made the Keystone + Strata Run Dominate
It did not merely edge out Forge. In Mike's review, it absorbed Forge's strengths, fixed Forge's weaknesses, and added capabilities neither prior run had.
1. It restored the audit design Forge had lost
Forge's clearest weakness was audit design: a pre-side-effect write and an opaque payload_hash instead of readable state. Keystone + Strata restored same-transaction audit writes and readable before_state and after_state, then added a correlation ID linking each API call to its audit rows.
| Audit dimension | Keystone Q4 | Forge IQ3_S | Keystone + Strata IQ3_S |
|---|---|---|---|
| Same-transaction write | Yes | No | Yes |
| Readable before/after | Yes | No - hash only | Yes |
| Correlation ID | No | No | Yes |
2. It kept Forge's code defensiveness
The defensive details that made Forge's code stronger than Keystone Q4's survived. The later Keystone run also introduced a circuit breaker on the ledger and capped exponential backoff - two layers neither prior run had.
| Code detail | Keystone Q4 | Forge IQ3_S | Keystone + Strata IQ3_S |
|---|---|---|---|
| Timeout below retry trigger | No | Yes - 450 ms | Yes - 500 ms |
| Money as integer cents | No | Yes | Yes |
| Explicit lost-race branch | Implicit | Yes | Yes - state machine |
| Circuit breaker on ledger | No | No | Yes - new |
| Capped exponential backoff | No | No | Yes - new |
3. It produced the best long-context extraction of the three
| Keystone Q4 | Forge IQ3_S | Keystone + Strata IQ3_S | |
|---|---|---|---|
| Rows extracted | 10 | 11 | 14 |
| Quote fidelity | Verbatim | Paraphrased | Verbatim |
Mike's review found that the later Keystone run captured everything Forge caught, kept Keystone's verbatim quoting, and added details both prior runs had missed.
4. It produced the sharpest multimodal answer in the benchmark
Both earlier runs correctly identified that the diagram's edge style disambiguated whether authentication validation was a local JWKS check or a synchronous network call. The later Keystone run went further by connecting the authentication topology to both rollback criteria: latency and error rate. That was a practical operational insight supported by the source material but not stated directly.
The Scorecard: Why 9.3 Beat 8.9
| Dimension | Keystone Q4 | Forge IQ3_S | Keystone + Strata IQ3_S |
|---|---|---|---|
| Long-context retrieval | 8.5 | 9.0 | 9.5 |
| Agentic coding - code | 8.5 | 9.5 | 9.5 |
| Agentic coding - audit | 9.5 | 8.0 | 9.5 |
| Structured output | 7.5 | 8.0 | 9.0 |
| Multimodal reasoning | 9.5 | 9.5 | 9.8 |
| Instruction adherence | 8.5 | 9.0 | 9.0 |
| Premise verification | Not attempted | Yes | Not tested |
| Overall | 8.6 | 8.9 | 9.3 |
The structural result: in Mike's scoring, Keystone + Strata matched or exceeded Forge on every dimension Forge had won and recovered the audit dimension Forge had lost. There was no longer a quality trade-off.
The Critical Discovery: Same Quant, Different Hardware
The later run made the comparison much cleaner. Forge and Keystone were both running Strata + Flash Next at IQ3_S. The primary hardware difference was Forge's V100 with 32 GB of memory versus Keystone's RTX PRO 6000 Blackwell with 96 GB.
| Forge | Keystone + Strata | |
|---|---|---|
| Model | Strata + Flash Next | Strata + Flash Next |
| Quantization | IQ3_S | IQ3_S |
| Hardware | V100 32 GB | RTX PRO 6000 Blackwell 96 GB |
| Reported score | 8.9 | 9.3 |
Same model. Same quantization. Different hardware. A reported 0.4-point gap. That result undercuts the earlier idea that Forge's audit weakness was necessarily caused by quantization: the same quantization on Keystone produced the strongest audit design of the three runs.
The hardware difference and Keystone's additional memory and compute headroom are the leading explanation for the result, but this was an owner-run comparison rather than a controlled laboratory study. Runtime settings, sampling, and ordinary run-to-run variation can also affect model output, so the score should not be read as proof that hardware alone caused every difference.
The Efficiency Story Forge Still Owns
The quality crown moved to Keystone, but the value story did not disappear. In the reported Forge measurements, moving from Qwen 3.8 27B to Strata + Flash Next produced a larger model that ran roughly twice as fast, at lower power, cooler, and near-silent.
| Qwen 3.8 27B | Strata + Flash Next | |
|---|---|---|
| Power draw | 200+ W sustained | 50-130 W |
| Fan behavior | Full ramp | Barely ramps |
| Temperature | 55-60 C | Under 45 C |
| Speed | About 25 tokens/sec | 50-60 tokens/sec |
That remains Forge's achievement: a larger model, roughly twice the speed, lower power draw, cooler operation, and near-silent behavior on a budget-conscious system.
The Corrected Conclusion
The original benchmark framed Forge as the value winner and Keystone as the expensive machine that lost. Adding Strata to Keystone changed the quality result:
- Forge remains the efficiency champion: an owner-reported 8.9 out of 10 from roughly $2,500 in estimated hardware before labor, with strong power, thermal, and acoustic results.
- Keystone + Strata became the quality champion: an owner-reported 9.3 out of 10, the highest score in the benchmark, at the same IQ3_S quantization used on Forge.
- The higher-end hardware finally showed why it was there: once both machines used the same enhancement layer, Keystone combined Forge's coding strengths with Keystone's audit strengths and added defensive layers neither earlier run had produced.
The turning point was loading the same Strata model onto Keystone. The result was not a narrow win in Mike's review. It was the run that absorbed Forge's strengths, fixed Forge's weaknesses, and made Keystone's additional compute and memory headroom worth the investment.