Skip to content
Corbenic Emblem Corbenic Galahad Memory Layer
Technology Benchmarks Pricing Research About Careers
Request a pilot

Measured results

Benchmarks and methods

Measured September and October 2026 · Google Gemma 4 · NVIDIA GPUs

Galahad saves a model's computed state (its KV cache) to encrypted disk and loads it back exactly, instead of recomputing it. This page lists what was measured, on what, and where the limits are. Every figure comes from Corbenic's own tests and the papers linked at the bottom. Your results will depend on your model, hardware and workload.

How the tests were kept honest

  • No mode is told where an answer is. The benchmark only watches and measures.
  • The model cannot already know the answers: the questions use invented names and random 5-digit numbers, each asked ten different ways.
  • Every question starts cold. The runtime's own cache is emptied first.
  • Every try is paid for. Time, energy and tokens include every block restored.
  • Energy is read from the GPU's own hardware counter (NVML), not estimated.
  • Temperature 0. Repeat runs gave the same answers, and energy differed by at most 1.5%.

Against the plain model

Gemma 4 31B, 100 questions over a 120,000-token corpus, cold start. Galahad with reuse and built-in retrieval.

Right answers, time and GPU energy per question, without and with Galahad
RuntimeRight answersTime per questionGPU energy per questionEnergy gain
llama.cpp10 to 1009.25 s to 0.64 s2,754 J to 213 J12.9×
vLLM10 to 1008.11 s to 0.59 s2,402 J to 200 J12.0×
SGLang10 to 10010.29 s to 0.64 s2,940 J to 210 J14.0×

Hardware: NVIDIA RTX A6000 (48 GB). llama.cpp, vLLM 0.29 and SGLang 0.5.20.

Against a standard RAG system

RAGFlow v0.27.2 at default settings, same model, same text, same 100 questions, vLLM warm. RAGFlow ran on an L40S, a faster card.

Galahad compared with RAGFlow on the same questions
MeasureGalahadRAGFlow
Right answers100 / 10054 / 100
Time per question (median)0.59 s1.70 s
GPU energy per question201 J506 J
Tokens sent to the model per questionabout 670about 3,100

A 50-million-token memory on one GPU

50,000,000 tokens read once and stored as 3,125 encrypted blocks. 100 probes, from the first token to 49.5 million tokens deep. One NVIDIA H100, vLLM 0.31.0 with the Galahad connector, galahad-kv 1.31.4. Described in arXiv:2610.10845.

Restore and recompute results for a 50-million-token memory
MeasureGemma 4 12BGemma 4 31B
Blocks restored with zero recompute100 / 100100 / 100
Exact answers from the restored memory82 / 10098 / 100
Restore, median time and GPU energy0.266 s · 59 J0.347 s · 80 J
Recompute, time and GPU energy0.76 s · 521 J1.48 s · 976 J
Gain, speed and energy2.8× · 8.8×4.25× · 12.3×
Invented answers when the record was not there0 of 200 of 20

One block is in GPU memory at a time, so depth is retrieved, not attended to all at once. The result is reuse of stored state, not a wider attention window. Storing the memory is a one-time cost: about 20,839 tokens per second for the 12B model and about 10,700 for the 31B model, using 1.86 TB and 6.7 TB of disk.

Restart at 2 million tokens

About 2 million tokens (80 long documents) ingested until they overflow GPU memory, then the server is restarted so the GPU is cold and each document is queried again. NVIDIA L40S, Gemma 4.

Cold re-query after a server restart
SetupTime to first tokenEnergy per requestRecall
vLLM alone4.95 s12,656 J8 / 8
vLLM with Galahad1.81 s1,614 J8 / 8

Messy, real data

Seven public Hugging Face datasets (help-desk tickets, support tickets, messy PDFs, GitHub issues, raw source code, agent traces and browser-agent traces), 349 questions, with every question and answer taken from the dataset itself. Scored by text match, with no AI judge. Galahad answered 91% to 95% correctly across the three setups and both modes. The reuse-only mode on the embedded setup answered 333 of 349 (95%). The hardest set was messy PDFs, at 32 to 38 of 50.

Exactness and coverage

  • Bit-identical restore: logits matched across all 262,144 vocabulary entries after save, restart and restore (Gemma 4 12B, llama.cpp). 27 checks, 0 failures.
  • Models: 30 of 30 open models from 10 publishers saved, loaded and reused on the shipped build, up to 70B on 4 GPUs.
  • Hardware: 12 NVIDIA GPU models, from T4 to H200, on AWS, Google Cloud, RunPod and vast.ai.
  • Engines: llama.cpp, vLLM and SGLang.
  • Reliability: 2,918 requests answered with 0 failures through a Kubernetes rolling restart.

Limits you should know about

  • These are Corbenic's own measurements, mostly on Google Gemma 4 and NVIDIA GPUs. They have not been independently reproduced. Other models, engines and hardware will give different numbers.
  • The benchmark questions are lookup questions over a text corpus. Workloads with little repetition will see less benefit.
  • The 50-million-token result is stored-state reuse. On the 12B model, 82 of 100 probes returned the exact code, and 98 of 100 on the 31B model.
  • Reuse-only runs on cold vLLM and SGLang were measured before a later fix and are not shown here. Full measurements and test configuration are available on request.

Papers

  • arXiv:2610.10845: a 50-million-token window that is faster and cheaper than recompute
  • arXiv:2609.39358: byte-exact memory in Galahad makes LLM reading a one-time cost
  • arXiv:2607.23806: a frozen 12B beats frontier models on verified work
  • arXiv:2607.14431: byte-exact KV-cache grafting and the verified-knowledge flywheel
  • arXiv:2605.09990: Merlin, byte-exact deduplication
  • arXiv:2605.09611: byte-exact deduplication in RAG across three regimes

Want to measure it on your own workload? Ask for a pilot. The community package is installed with pip install galahad-kv and the code is at github.com/corbenicai/galahad.

Corbenic Emblem Corbenic AI

The persistent, byte-exact memory layer for companies running LLMs on their own servers.

Delaware C-Corp

Product

Merlin, Taliesin & Blaise Benchmarks & Methods arXiv Papers Engineering Notes Changelog

Company

About Careers Security Press & Brand GitHub Repository

Inquiries & Legal

Contact [email protected] Privacy Policy Cookie Policy Terms of Use Sub-processors Responsible Disclosure

© 2026 Corbenic AI, Inc. All rights reserved. Patent pending.

corbenic.ai·Delaware Registered Entity·Patent Pending