Corvid Cloud support AI: where the LLM bill goes, and the six changes that cut it

Executive summary

At 1,200,000 requests a month the support assistant costs $23,117. Six changes bring it to $531, a saving of $22,586 a month. Quality: 76 of 81 checks pass (78 before); every miss is listed. Three changes do most of the work: trim the prompt and retrieved context ($13,410), cap output and reasoning ($5,000) and route easy calls to a cheaper model ($3,488). Each call is priced at the list price of the model that served it.

• Cost per request falls from $0.019264 to $0.000443. At that rate a $1,500 audit is covered after about 79,700 requests.
• Quality: 76 of 81 checks pass after, 78 of 81 before. The 5 remaining failures are listed in full; 2 of them also fail on the baseline.
• Baseline shape. The baseline is a typical unoptimized stack: one big reasoning model on every call, a 3,073-token system prompt, 10 retrieved chunks, no output caps. A leaner stack starts from a lower bill; the free AI check (a one-page report within 48 hours) sizes the saving to yours before you pay.

Baseline: what the bill is made of

On your bill the baseline is your last full invoice month, reconciled line by line against a usage export, and we report the variance. Here the baseline is the API usage field of each of the 81 baseline calls, priced at Claude Sonnet 5.5 list prices ($2.00 per million input tokens, $10.00 per million output). The table re-adds those calls and checks the sum against the analysis.

Re-added total $23,116.77 against the analysis figure $23,116.77: variance $0.00.

Per month = sample cost × 1,200,000 / 81. We assume the 81-request mix repeats at 1.2M requests a month; about 10 percent of that volume is per-account nightly digests. The nightly digest is 8 of 81 calls but 30% of the cost: its average output was 5,092 tokens.

Savings by lever

Levers were applied one after another on the same 81 requests. Each section shows the money, one measured request before and after (cost per call at the list price of the model that served it), the code change that makes it, and how to undo it.

 def answer(question):-    chunks = search(question, top_k=10)-    system = SYSTEM_PROMPT        # 3,073 tokens+    chunks = rerank(search(question, top_k=20))[:3]+    system = POLICY_PACK + RULES  # 1,792 tokens, same rules     return llm.chat(BIG, system, render(chunks, question))

+MAX_TOKENS = {"qa": 320, "classify": 12, "summarize": 220, "report": 800} def chat(task, model, system, user):-    return create(model, system, user)+    return create(model, system, user,+                  max_tokens=MAX_TOKENS[task],+                  reasoning="low" if model == BIG else None,+                  format=TERSE[task])  # e.g. one label

+SENSITIVE = ["refund", "delete", "deletion", "gdpr", "privacy", "security", ...]+def route(task, question):+    if task != "qa": return SMALL+    if any(k in question.lower() for k in SENSITIVE):+        return BIG+    if needs_arithmetic(question): return BIG+    return SMALL++def answer(question):+    out = chat(route("qa", question), ...)+    if doubtful(out, retrieved):  # unsure, no or bad cite+        out = chat(BIG, ...)      # re-run on the big model+    return out

-    system=system,+    system=cached(system),  # policies + label definitions+    # the cached prefix must not change between calls

 def answer(question):+    hit = cache.get(question)  # exact, then normalized+    if hit: return hit     out = ...+    cache.put(question, out)   # flushed when the KB changes

-for account in accounts:-    digest = llm.chat(task="report", ...)+jobs = [digest_request(a) for a in accounts]+batch = submit_batch(jobs)  # half price, done within 24 h+# results collected by the 06:00 job

Each code change is a provider-neutral sketch in the shape it would land in your repository; the real change uses your provider’s SDK. Caching, dedupe and batch were priced on measured tokens rather than run as separate model calls.

Price comparison: the same tokens on each provider’s list

The result in this report prices each call at the list price of the model that served it: $23,117 to $531 a month, the “As run” row. For comparison only, the same measured token counts are also priced as each provider’s big and small tier, our mapping to its commercial models. Claude Sonnet 5.5, GPT-6.1 Sol, Gemini 4 Carbon all list at the same $2.00 in and $10.00 out per million tokens, so the before bill is the same on every list; the after bill moves with each small model’s price.

Google’s Gemini 4 Carbon list prices rise on 1 Dec 2026; the table uses the prices valid on 11 Nov 2026.

Quality check

Nothing ships that fails the quality check. The classifier is scored by exact label match; everything else by a grading model (Gemini 4 Argon, a second AI model) with a written rubric (correct, complete, policy-safe), the full knowledge base, must-have facts and a must-not list.

How the pass rate moved while tuning

1. Baseline78/81
2. First optimized pass59/81
3. + escalation and numeric routing62/81
4. + digest counts in code, 90-word summaries72/81
5. + 90-word support answers (shipped)76/81

Every check that still fails

Risks and rollback

Each lever ships behind its own flag, so any one can be turned off without touching the others. The quality check runs on every code change and nightly for the 30 days after.

30-day verification plan

Savings are measured per request, so a busier or quieter month does not change the answer. The baseline cost per request is frozen before any code change merges.

1. Day 0Freeze the baseline: last full invoice month, reconciled with the usage export, divided by its request count. Sample: $0.019264 per request.
2. Days 1–3Merge the code changes behind flags. Turn them on for 10% of traffic; compare cost per request and quality pass rate against the other 90%.
3. Days 4–7Full traffic once the reserved test set scores within the agreed margin of the baseline. Any lever that fails is switched off and listed in the report.
4. Days 8–30Daily cost per request from the usage export, nightly quality check on the reserved test set, an alert if either drifts.
5. Day 30Reconcile the invoice. Verified saving = (baseline cost per request − new cost per request) × requests actually served. Sample: ($0.019264 − $0.000443) × 1,200,000 = $22,586.

The guarantee

• Shipped code changes, one per lever, each behind a flag
• A quality test set built from your own traffic, with a reserved test split
• A before and after report reconciled to your invoice
• A ranked fix list with dollars per fix

Method

• Workload. 81 requests: 37 support questions over a 32-chunk knowledge base (8 are repeats or rephrasings), 24 ticket classifications with correct labels, 12 ticket summaries, 8 nightly digests.
• Models. Big Claude Sonnet 5.5 (run as claude-sonnet-5-5-high), small Gemini 3.1 Flash-Lite (run as gemini-3.1-flash-lite), grader Gemini 4 Argon (run as gemini-4-argon-high). Tokens from each call’s usage field; each call priced at its model’s list price.
• Caching assumes 95% of a stable prefix of at least 1,024 tokens is served from cache; cache expiry and storage fees are reconciled against your invoice when we run it on your bill. Dedupe found 3 exact and 5 normalized repeats in 81. Batch is priced at half.
• Scoring. Every stage is a real run at temperature 0, scored by exact label match and by one grading model with a written rubric. On your traffic we add repeated runs per stage and the held-back test split.
• Data. Raw data: results.json. The baseline above is re-added from the run log and must match the analysis before this report is built.