What sovereign AI can save you

Scope. The customer enters annual token volume and picks up to six destinations. The not-optimized figure prices 100% of that volume against a single frontier model on the right, adjusted for a small set of real-world concessions the customer would already apply without Akka. The optimized figure prices the same volume against the selected destinations, then applies each active routing technique on top. Amounts are annual, in US dollars, at list price. This estimate is a planning aid; it is not a quotation and it commits neither Akka nor any provider.

Model selection. Traffic is split evenly across the selected destinations, so a selection of four models gives each 25% of tokens. The cheapest selection sets the cheap tier and the most expensive sets the frontier for the routing techniques below; the middle selections take the base distribution rate and nothing more. Selecting one model collapses cascade and planner/worker to no-ops, since neither has a distinct cheap tier or frontier to route between. Mixing API and self-hosted destinations is supported and expected.

Per-token API rates. First-party direct-API rates from Anthropic, OpenAI and DeepSeek, verified 16 August 2026 and stored in audit/rates.json. GPT-5.6 Sol is listed at half its $5.00/$30.00 standard rate under a 50% discount; if that discount lapses the rate doubles. DeepSeek rates are cache-miss input; peak and off-peak pricing was announced for 16:00 UTC on 16 August 2026, so these rates are the flat-rate era and should be re-checked. Anthropic and OpenAI models are proprietary: weights and adapters are not distributed, so a routing decision that would send traffic to a self-hosted equivalent runs against an open-weight model rather than the API one.

Self-hosted rates. Self-hosted destinations do not have a per-token rate card. Their effective per-million-token cost is the chosen GPU hourly rate divided by serving throughput, further divided by 40% endpoint utilisation because a reserved node bills whether or not it is serving. The baseline calibration is $0.09 input and $0.62 output per million tokens on a mid-class 30–50B open-weight model, derived from a Google a4-highgpu-8g endpoint carrying eight NVIDIA B200 at $16.11 per GPU-hour and the throughput model described below. Small open-weight is modelled at half that rate and large open-weight at twice, on the basis that per-token cost scales roughly with active parameter count. A future rates.json refresh should carry canonical per-model-class per-million-token rates rather than a scalar multiplier.

GPU source and cloud. Akka Platform is priced against the customer's chosen cloud for platform services and against the chosen GPU source for self-hosted inference. In-VPC options are the reserved and on-demand rates published by the chosen cloud. Neocloud options run outside the cloud VPC and are enumerated in full regardless of cloud choice: Lambda at $1.49 and $2.99 per GPU-hour, Nebius committed and on-demand, and CoreWeave committed and on-demand. AWS reserved figures are $27.52 per H100-hour and $56.97 per B200-hour; AWS on-demand doubles to $55.04 and $113.93. Azure reserved is $59.00 and $121.00, on-demand $98.32 and $201.67. Google reserved is $83.19 and $128.88, on-demand $88.49 and $128.88; the Google reserved B200 rate uses the three-year committed-use discount published for a3, since a4 is routed through the AI Hypercomputer reservation system rather than the committed-use machinery.

Serving throughput. Per-GPU serving throughput is modelled at 25,000 tokens per second prefill and 3,000 tokens per second decode on an H100 at a 12B dense equivalent, scaling as 1/N with active parameter count. B200 is modelled at three times H100 throughput on prefill and decode, matching the ratio used in the reserved-capacity table of the main calculator. Prefill is compute-bound and decode is bound by memory bandwidth. These figures are first-principles rather than benchmarked, and mixed sequence lengths are expected to reach only half to two-thirds of them; the derived per-million-token rate above already incorporates that assumption.

Not-optimized side. Starts at the chosen frontier model's blended rate. Some traffic already goes to a cheaper model replaces the configured share with a mid-tier or small-tier API selection at its published rate. Annual vendor volume commit applies a flat discount to the remainder at published enterprise schedules: 5% at $50k a year, 10% at $250k, 15% at $1M, 22% at $5M. These figures are corroborated against OpenAI and Anthropic enterprise disclosures and should be verified per customer. Provider prompt-cache discount reduces the input-token share of cost by the configured prefix hit rate times (1 − 12.07%), matching the effective input rate measured across 969 Claude Code transcripts and 50,279 API calls. Batch API pricing applies a 50% discount to the configured async share; Anthropic and OpenAI both publish 50% off for up-to-24-hour turnaround.

Semantic response cache. The hit share of tokens pays nothing. A hit is a nearest-neighbour lookup against previously served responses in an embedding index; the hit rate depends on how much of the workload is recurring and is a customer-specific figure. Reference implementations include GPTCache (MIT) and aurelio-labs/semantic-router (MIT); Akka's shipped semantic-router embedder is the natural substrate. The current design assumes a customer-specific hit rate rather than a modelled default across workloads.

Cascade / escalation. Cascade is not a routing consumer; it is a policy applied to frontier calls. For the configured share of frontier-bound traffic, the effective per-token rate is the cheapest selection's blended rate plus the escalation rate times the frontier blended rate. That fraction replaces the frontier contribution to the base distribution cost. Output-shape triggers (refusal, empty answer, format violation) provide the free-floor escalation signal; a small critic model or log-prob confidence tightens it further. Reference implementations include FrugalGPT (Apache-2.0) and AutoMix (Apache-2.0).

Planner / worker role binding. Modern coding harnesses (Claude Code, Aider, Cursor, LangGraph, DSPy, CrewAI) already expose distinct planner and worker slots. For the configured agentic share of traffic, the planner-side takes the most expensive selected model and the worker-side takes the cheapest, with the worker turn ratio setting the split. The gateway does not decide the split — the customer configures their own harness — but the resulting cost ratio is legible in the routing capture and priced here. Coding trajectories are 80–95% worker turns in published measurements.

Sticky session routing. Multi-turn conversations get a prompt-cache discount on the repeated prefix only when every turn goes to the same provider. Cost is scaled by (1 − multi-turn share × cached-prefix share × input weight × prompt-cache saving). Cached-prefix share within a multi-turn session is modelled at 70%, input weight at 50% (input tokens are roughly half the blended cost for typical rate cards), and the prompt-cache saving is (1 − 12.07%) matching the effective input rate above.

Prompt compression. A small model rewrites verbose prompts to preserve meaning while cutting the token count on the eligible share. Cost is scaled by (1 − eligible share × compression ratio × input weight). Input weight is 50% as above; the compression ratio is a customer-specific figure since it depends on prompt shape. Reference implementation is LLMLingua and LLMLingua-2 (MIT). Aggressive compression carries a measurable quality drop and is best used on retrieval-heavy workloads with long stuffed context.

SLM training. A trained specialist model consumes approximately 40% of the prior input tokens and produces 60% of the prior output tokens on a model requiring half the compute per token, giving roughly a 75% cost reduction on the eligible slice. Cost is scaled by (1 − eligible share × 0.75). Only enabled when at least one self-hosted model is in the selection, because the trained specialist has nowhere to run without hosting infrastructure. Adapters are served as LoRA weights on a shared base model, adding under 1 GB of GPU memory each; training executes against idle reserved capacity and carries no incremental charge in the Akka figure.

Rate multipliers on self-hosted destinations. The GPU source picker sets a multiplier applied to every self-hosted per-million-token rate in the compute. The reference is AWS reserved B200 at $56.97 per GPU-hour divided by throughput factor 3, giving $18.99 per throughput-normalised hour. Chosen / reference gives the multiplier: AWS reserved B200 lands at 1.00, on-demand at 2.00, Nebius committed B200 at 0.50, CoreWeave on-demand H100 at 2.60, GCP reserved B200 at 2.26. Cloud choice affects the multiplier when an in-VPC source is picked; a neocloud source is independent of the cloud choice.

Akka Platform overhead and break-even. The optimised figure applies a variable margin on the compute cost and adds a single fixed annual platform floor that covers compute, storage, network, licence and connectivity together. Margin is 50% at or below five trillion tokens a year and declines log-scale to 18.8% at one thousand trillion. The fixed floor is $100,000 a year. Break-even solves for the token volume where not-optimised equals optimised: V* = fixed / (rate_notopt − rate_opt_after_margin). Below V* the platform floor outweighs the routing savings and the customer pays less by staying on the not-optimised path; above V* the per-token savings dominate.

Headcount equivalents. The break-even volume is restated as the number of people whose annual consumption matches it. Each row is an independent reading of the same volume rather than a component of a sum: the volume that matches four engineers is the same volume that matches six support agents, and the two are alternatives. A person is modelled on an eight-hour day with three hours away from the keyboard, leaving five working hours, and works AI-natively, with the assistant in the loop continuously rather than consulted occasionally. Working days are 230 a year — 260 weekdays less public holidays and paid leave — except support, which runs 250. Annual consumption is tokens a day times working days, and the headcount is the break-even volume divided by that annual figure.

Per-person token consumption. Context replay dominates these figures, not prompt length. Inside an agent loop every turn resends the accumulated context — files read, tool results, prior reasoning — so a task running twenty-five turns against a context grown to 150,000 tokens bills on the order of two million tokens, roughly fifty times what its visible prompt suggests; counting prompts alone understates every role by more than an order of magnitude. The engineer's 20 million tokens a day is seven such tasks plus eight code reviews, trace debugging, and background agents that keep running while the engineer is away from the desk. The support agent's 12 million is forty retrieval-backed tickets, each a draft, critique and revise loop over knowledge-base chunks and full customer history, plus a live chat copilot held in context. The analyst's 12 million is twelve text-to-SQL cycles that replay full warehouse schema on every revision, three drafted reports and an hour of notebook agent work. The executive's 7 million is four long-document sessions with follow-ups and two deep-research runs across twenty to forty sources each. The power user's 200 million a day is a ceiling case rather than a role: five agentic systems driven concurrently through a six-hour day, with unattended loops — test repair, refactor sweeps, eval harnesses — continuing overnight, which decouples consumption from the hours the person is present. Across 230 days that is a billion tokens a week, an order of magnitude beyond the AI-native engineer, and it is bounded by agent wall-clock rather than human attention. The document row is throughput rather than a person: one fifty-page contract worked end to end — ingest, eight targeted extraction passes, clause classification, risk scoring and a summary with a QA check — is 350,000 tokens. Volume is counted as raw tokens processed, replay included; prompt caching changes what a token costs rather than how many are processed and is modelled separately on the not-optimized side, so replayed context is not discounted twice. These allocations are first-principles rather than measured, and consumption varies with how aggressively a team adopts agentic tooling.

General. All amounts are in US dollars at list price. No enterprise discount, private pricing agreement, reserved instance, savings plan, capacity block or other committed-use discount is applied beyond those stated in the volume-commit checkbox on the not-optimized side and the reserved rates on the GPU source picker. Amounts exclude customer personnel, third-party software and infrastructure outside the fleet described. Sources: Amazon Bedrock and Amazon EC2 pricing; Azure AI Foundry and Azure Virtual Machines pricing; Google Cloud Vertex AI and Compute Engine pricing; Anthropic, OpenAI and DeepSeek platform pricing; the Microsoft Azure LLM inference traces; Artificial Analysis; RouteLLM, GPTCache, FrugalGPT, AutoMix and LLMLingua published references for the routing-technique multipliers.