A 95% cheaper AI worker. Here's what the whole job cost.

Use a capable, cheaper AI for the coding. Keep a stronger model checking the work. Does that actually save money?

We tested it on a real repair from KrystalView, our analytics product. Three approaches. The same task. The same final checks. No made-up workload and no changes to production.

The DeepSeek worker cost 94.94% less than the conventional frontier worker. After counting independent review and a share of all the model evaluation, total measured API cost was 24.64% lower.

Those are different numbers for a reason. A cheaper worker is a win. Pretending the checking is free would not be.

One real bug. Three ways to fix it.

The bug was straightforward to describe: ask for unread notifications and you could get an empty page, even when unread notifications existed. The system was filtering the results at the wrong stage.

We took a frozen snapshot of 255 files, about 2.45 MB, and gave each approach the same bounded repair. Each could search and read the relevant code. Nobody was forced to read the whole repository just to make the comparison look impressive.

• Conventional frontier: a strong coding model searches, implements and checks its work, followed by fresh final review.
• Frontier KLP: a strong worker receives a focused brief and an independent critic checks the result.
• DeepSeek KLP: a lower-cost DeepSeek worker does the implementation, with the same frontier critic checking it.

This is the practical idea behind Krystal Loop Protocol: give each agent a clear job, keep the important requirements intact, and make the result earn acceptance.

The worker saving was big. The total still mattered.

Here is the full measured API breakdown. The shared evaluation cost covers model readiness checks and final reviews, split equally across the three approaches as agreed before the run.

• Conventional frontier: $0.3595. Worker $0.2016, plus $0.1579 shared evaluation.
• Frontier KLP: $0.4228. Worker $0.1607, critic $0.1042, plus $0.1579 shared evaluation.
• DeepSeek KLP: $0.2709. Worker $0.0102, critic $0.1028, plus $0.1579 shared evaluation.

Totals use unrounded receipts. DeepSeek KLP was 24.64% lower than the conventional approach and 35.91% lower than frontier-only KLP. All three runs and shared evaluation together cost $1.0532 in measured API usage.

There is an important result in the middle: frontier-only KLP used fewer input tokens, but its review cost made it more expensive on this repair. Choosing the roles and models matters, not just shortening the prompt.

The checking caught something real.

The conventional worker's first fix passed the initial checks. A fresh reviewer then spotted a compatibility bug: one existing way of supplying an empty filter would return the wrong notifications.

We checked the finding against an isolated database. It was real. The worker repaired it, added a regression test and passed again. That repair and the extra review are included in the costs, not quietly dropped from the result.

Both KLP approaches passed their in-loop and final experiment reviews without a formal repair round. All three final candidates passed the same 15 frozen checks and their own regression tests.

A later integration review caught another compatibility gap in the DeepSeek candidate: an unset stored read flag was treated differently from before. We reproduced it and made a small correction. That later work is outside the experiment's API figures. The integrated fix includes this correction; it has not been deployed or restarted into production. Passing the experiment was not a guarantee of perfection.

What the dollar figures include

All 55 inference calls are accounted for, including extra reads, worker self-corrections, critics, the repair and shared final evaluation. Costs use reported input, cached input, cache writes and output at the recorded test-date rates. DeepSeek ran at its off-peak rate. These are calculated API costs, not reconciled invoices.

The coordinator's subscription cost is not in that dollar total. Its experiment setup and oversight usage is disclosed in the case study: 16,770,741 cumulative input tokens, mostly cached, and 40,269 output tokens through the closing checkpoint. Its cash allocation was unavailable, not zero. Later integration and article preparation are separate work too.

This was one KU-run task, not a universal saving or an independent audit. The result compares complete workflow configurations; it does not prove that a particular symbol, message format or model will make every project cheaper or more accurate.

For people building with AI

You do not have to use your most expensive AI for every part of the job. A capable cheaper worker can do the implementation while a stronger reviewer checks the result against the brief.

Keep the ambition. Split the work. Count the checking. That is the useful result here: a much cheaper worker and a lower measured experiment API total, with review still doing real work during integration.

Read the receipts. Try the approach.

Give the repository to your coding agent and ask it to apply KLP to one bounded task. It does not need to run a benchmark first.

• Krystal Loop Protocol on GitHub
• Full case study, model settings and cost breakdown
• Sanitized call receipts