Inference Optimisation

Fast enough that people use it, cheap enough to keep

The same model on the same hardware can cost ten times more or less; we find the operating point where latency and bill both fit.

  • Self-hosted, cloud or hybrid
  • vLLM, TensorRT-LLM, SGLang
  • Cost per resolved conversation
  1. 01 Latency budget TTFT and p99 agreed before any tuning
  2. 02 Traffic routing Cheapest model that clears the bar
  3. 03 Serving engine Continuous batching, chunked prefill
  4. 04 KV cache Paged attention, prefix reuse
  5. 05 GPU memory bandwidth The substrate decode speed is bound by
Decode is bandwidth-bound, so every layer above is really a fight for the memory the cache wants.

Economics

Latency and cost are the same trade

Bigger batches raise tokens per second and raise time-to-first-token with them. Aggressive quantisation cuts memory and can cut quality. We agree the budgets first, in milliseconds and in currency, then tune against them.

  • TTFT and tail latency budgets agreed before tuning
  • Cost tracked per million tokens and per conversation
  • Every change gated on your eval set, not a benchmark

Throughput

2–4×

typical gain from continuous batching over static batching

Latency

sub-300ms

time-to-first-token target for interactive chat workloads

Cache

The KV cache is the real budget

On a loaded server it is attention memory, not weights, that caps concurrency. Prefix reuse removes the long preamble every agent and RAG request repeats.

  • paged attention
  • prefix cache
  • chunked prefill

Fleet

Route before you scale

Send cheap traffic to a small model, serve dozens of LoRA adapters from one base, and scale on queue depth rather than CPU.

  • multi-LoRA
  • tiered routing
  • MIG
  • queue autoscale

Quantisation

Smaller weights, same answers

FP8 and INT8 are close to free on current hardware. INT4 quarters weight memory but costs quality unevenly, so we re-run your eval set before shipping it.

  • FP8
  • INT8
  • AWQ
  • GPTQ

Serving engines

  • vLLM
  • TensorRT-LLM
  • SGLang
  • TGI
  • Triton
  • llama.cpp

Orchestration

  • Ray Serve
  • KServe
  • Kubernetes
  • Ollama
  • MIG

Quantisation

  • FP8
  • INT8 SmoothQuant
  • AWQ
  • GPTQ
  • W4A16

Cache and decode

  • Paged attention
  • Prefix caching
  • Chunked prefill
  • Speculative decoding

Measurement

  • Prometheus
  • Grafana
  • OpenTelemetry
  • Langfuse
  • Trace replay

Who we do this for

  • Product teams shipping interactive AI
  • Enterprises self-hosting open models
  • Regulated institutions serving in-estate
  • High-volume API consumers
  • Platform and service providers

Three ways in. Stop after any of them.

1–2 weeks

Serving cost and latency audit

We benchmark your current stack under replayed traffic and rank the available wins by effort.

Baseline benchmark, cost per million tokens, ranked list of wins

4–10 weeks

Optimisation programme

Engine tuning, cache and batching, quantisation behind quality gates, routing — each shipped by shadow then canary.

Tuned configuration in version control, quantised artefacts, load-test suite

Ongoing

Managed inference operations

We run the serving tier under an SLA and re-tune it as traffic and model options change.

Capacity plan, cost reporting, model upgrade path

Questions

It depends on where you start. Untuned stacks usually give up the most to three dull things: no continuous batching, no prefix caching on a long shared preamble, and a frontier model serving traffic a small one handles identically. We measure your current cost first, and if the headroom is small we say so.

Below a steady, predictable volume a hosted API is cheaper once you price the engineers, the idle capacity you hold for peak and the on-call rota. Self-hosting wins at sustained high volume, tight latency, or where residency rules leave no choice. Do not hire us to optimise a cluster you should not be running.

Shadow traffic first, so the new configuration answers real requests nobody sees. Then a canary with automatic rollback on latency or quality regression. Load tests use replayed traces, because prompt length distribution is what determines cache behaviour and a uniform test tells you a comfortable lie.

Talk to someone who has built this

Send us the constraint you are actually up against — budget, latency, regulator, deadline.