Latency is the silent killer of LLM-powered applications. A 500 ms delay in a chat interface feels sluggish, and in an agent loop that chains ten tool calls it becomes unacceptable. While model size and context length grab headlines, the real engineering challenge is serving inference fast enough for production traffic. This guide covers the techniques that move the needle, from speculative decoding to client-side tuning, with concrete code you can deploy today.
Speculative Decoding: Draft Small, Verify Large
Autoregressive transformers generate one token at a time. Speculative decoding breaks that serial dependency by using a small draft model to predict the next K tokens, then verifying all K in parallel with the target model. If the draft is mostly correct, you pay the latency of one large forward pass for K tokens.
Implementation requires access to both a draft and target checkpoint. If you self-host, pair a small draft model from the same family with the full Qwen 3 32B target. When using API providers, this optimization runs transparently inside the inference stack. The wins are largest for low-entropy text, such as code or repetitive formatting.
KV Cache Optimization: Memory Bandwidth Is the Bottleneck
For long-context workloads, the dominant cost is not compute but memory bandwidth. Each layer caches key and value tensors for every token in the prompt. Without optimization, regenerating or reloading these tensors on every turn wastes precious PCIe and HBM bandwidth.
Prefix caching stores shared prompt prefixes, such as system instructions and RAG documents, across multiple requests. Paged attention stores KV caches in non-contiguous blocks, eliminating memory fragmentation. Combined, these methods let you keep a 131K context hot, or even a 1M context window on models like DeepSeek V4 Flash, without the latency penalty of reprocessing it every time.
This is especially relevant for agentic workflows where the same tool definitions and conversation history are replayed repeatedly. Oxlo.ai hosts models like DeepSeek V4 Flash and Kimi K2.6 with 131K context, so efficient KV management is critical to making those context windows usable in real time.
Quantization and Distillation: Trim Weights, Preserve Accuracy
Moving from FP16 to INT8 or INT4 halves or quarters the model weights, which directly reduces memory bandwidth and increases tokens per second. Modern post-training quantization methods, such as GPTQ and AWQ, recover most of the accuracy loss by protecting sensitive outlier channels.
Distillation goes further by training a compact student to mimic a larger teacher. The result is a model like Qwen 3 32B that punches above its weight class, or coding specialists like Oxlo.ai Coder Fast that deliver high completion quality with lower latency than a 70B generalist. When evaluating a quantized model, benchmark your exact prompt distribution. A 4-bit Llama 3.3 70B may be indistinguishable from FP16 for summarization but degrade on rare reasoning patterns.
Continuous Batching and Scheduling
Static batching wastes GPU time because the batch must wait for the longest sequence to finish. Continuous batching, or in-flight batching, inserts new requests into the GPU as soon as others complete their generation. This keeps tensor cores saturated and improves tail latency under load.
As a client, you cannot control the provider's scheduler, but you can design your traffic to be scheduler-friendly. Keep prompts roughly uniform in length, avoid bursty synchronous loops, and use streaming so the first token reaches your user before the last one finishes. These habits let any inference backend, including Oxlo.ai, extract maximum throughput from its GPU pool.
Client-Side and Network Optimization
Server-side optimizations
