Independent research and consulting in HPC performance optimization, GPU computing, and AI infrastructure. We profile, analyze, and optimize at the intersection of hardware and software.
Understand the tools you're using — and keep the human in the loop.
A growing, plain-language guide to what AI models actually are, how they work under the hood, and how to use them humanely — the judgment, verification, and care that stay yours. Visual explainers, honest tradeoffs, no hype.
Three open mixture-of-experts models with about 3B active parameters (AMD's Instella, NVIDIA's Nemotron 3 Nano, and Qwen3 as a neutral reference), served on one AMD MI350X and one NVIDIA B300 with vLLM and SGLang, measured with GenAI-Perf definitions at three repeats per point. With the same vLLM version on both cards the B300 is 1.9x the MI350X for Nemotron and 1.5x for Qwen, so the home-turf gap was not a version artefact. Swapping vLLM for SGLang moves throughput by -15% to +24% depending on model and workload, more than vLLM version drift (within 5%) and far more than run-to-run noise (median 0.3%). And whether a model runs at all depends on the engine build: on the versions we tested, Instella served on none of them, on either vendor.
One question, "What is today's weather in Destin, FL?", traced through an AI coding agent: three prefill-and-decode rounds on the large model, a tool lookup, a web search whose result arrived pre-digested by something on the server, and a permission classifier on every tool call. Then the small models around the big one: what Claude Code documents (a Haiku-class background model, a separate model call for WebFetch, a Sonnet classifier for auto mode) and what it doesn't (session titles), six jobs a small model does well with examples from this session, where small models sit in other systems, and the bandwidth arithmetic that makes them cheap.
Backpropagation for one linear layer, in matrix form. With a trusted input x, an approximate matrix A and a target b that A x misses, the gradient of the squared error is the outer product of the residual and the input, r xᵀ. Each step multiplies the residual by 1 − η‖x‖², which is why the safe learning rate scales with the input and why networks normalise activations; at η = 1/‖x‖² the fix is exact and it is the smallest change to A that hits b. Then many examples (least squares and the normal equations), two layers (transposes carry the error backward), and what it means in practice — with a live 2×2 playground.
A compiler and a language model both turn text into text, and only one of them can go in a build system. The reason is worth spelling out, because it is not the obvious one. Determinism is what people cite — and a served LLM has less of it than they think: temperature zero is not determinism when your request shares a batch with strangers, and adaptive thinking means the model now chooses how much computation to spend per turn. But you could pin an LLM to bitwise determinism and it would still be unfit, because the disqualifying property is soundness. A compiler's failure mode is an error; a model's failure mode is plausible wrong output, and a toolchain cannot be built on a component that has no way to say it does not know. What follows from that is practical rather than gloomy: reproducibility is a ladder with five rungs, almost every engineering decision needs only the top two loosest ones, and the tests that establish them are cheap and mostly unwritten. Including the one nobody runs — the probe that measures your own non-determinism instead of assuming it.
Once you know where an agent's parts run and what crosses the wire, one practical question is left: which software do you actually install, and which of it can the agent drive by itself? That second half is the one nobody sorts for. Every piece of remote-GPU software falls into exactly three roles — the brain it calls to think, the hand it invokes as a tool, and the floor it never sees — and cuts again on whether there is a non-GUI surface an agent's act-step can reach. Sorted that way the landscape collapses usefully: model endpoints are nearly interchangeable because they all speak one HTTP shape, job runners are heterogeneous and are where your real choice lives, notebooks and remote editors are for you and not your agent, and CUDA-remoting products are the wrong layer entirely. A full inventory in five tables, the three rules that follow, and the honest status of each protocol and product.
Your agent runs on your laptop. The weights it calls run in a datacenter two thousand kilometres away, and the only thing that crosses between them is text — never GPU work. One ratio explains why the boundary sits exactly there: the internet is roughly 2,400 times the latency of a small NVLink collective, so you can afford to cross it once per request and never once per layer. That gives five possible topologies, of which one is the default, one is an anti-pattern, and three are situational. It also gives an uncomfortable corollary: everything that crosses the wire is plaintext at the far end, and for a coding agent that plaintext is your repository. So the second half is a catalogue of what you can actually do about it today — software options from prompt minimization to FHE, hardware options from SEV-SNP to confidential-mode GPUs with attestation before the first token — with the honest status of each, and a scenario table for choosing.
Exploring novel concepts pre-silicon — co-designing algorithm, runtime, and architecture before the hardware exists. A holistic, whole-system view, where the performance win comes from the full stack working together rather than any single layer.
AI Framework Performance
Profiling and optimization of PyTorch, NeMo, Megatron-Core, and inference runtimes (vLLM, TRT-LLM). End-to-end training and serving pipeline analysis.
GPU Architecture Analysis
Deep performance characterization on NVIDIA and AMD GPU architectures. Memory hierarchy analysis, occupancy tuning, kernel optimization using Nsight and ROCm profiling tools.
MPI, NCCL/RCCL communication optimization. Multi-node scaling analysis. Performance engineering for exascale-class systems.
Custom Instrumentation
Beyond vendor tools — custom profiling, roofline modeling, memory bandwidth characterization, and performance modeling for novel workloads.
Systems & Concurrency
OS and runtime effects that gate accelerators — memory allocation, NUMA placement, page faults — plus thread contention and data-race correctness across precisions and GPU architectures.