Maximize GPU throughput per watt per dollar

Continuous, agentic performance optimization for your GPU fleet. Zymtrace understands how your workloads execute, from CPU code to GPU instructions, and turns performance bottlenecks and reliability issues into silicon-aware fixes your AI agents and engineers can ship.

  • Cluster-wide
  • Self-hosted
  • Multi-silicon

We've been building Jev for a long time. We use Zymtrace for both training and inference. It's a significant step up from any of the competition and we view it as the best profiler on the market. It is our go-to tool for profiling training and inference and is also great for monitoring.

training throughput
+46%
faster inference
~10%
Read the TypeSafe case study
Erik Gafni CTO, TypeSafe
Maximize throughput per watt per dollar

Unified optimization layer for multi-silicon fleets

Silicon-aware and always-on, whether your fleet is all NVIDIA, all AMD, or a mix. Zymtrace sits between your AI workloads and the accelerators beneath them, turning execution data into hardware-aware optimization.

Distributed Training
Disaggregated Inference
Supervised Fine-tuning

zymtrace

Silicon-aware · Always-on · Agentic optimization

CPU x86 · arm64
NVIDIA CUDA · NVLink
ROCm · HIP
AWS Trainium Neuron SDK
Google TPU Cerebras coming soon · talk to an engineer →
How Zymtrace works

Tracing starts where execution starts: the CPU

Zymtrace picks up execution on the CPU with eBPF and traces it down to the accelerator. An MRI for your stack: it exposes the bottlenecks hiding between the layers, with minimal overhead.

Application code
Python · C++ · JAX · PyTorch
CPU execution attaches here
Host thread · scheduling · memory copy
Runtime layer
CUDA · ROCm · Neuron · OFI
Accelerator to instruction level
NVIDIA · AMD · Trainium

↑ observe from silicon up

Beneath the profiler

GPU topology health

When a performance problem isn't in your code, it's in your hardware. Zymtrace surfaces GPU health, topology, and interconnect issues that waste the compute you paid for.

NVLink health CRC, replay, and recovery per link
ECC and XID Memory and driver errors, fleet-wide
NUMA affinity Catch non-affine CPU placement
Actionable recommendations Not just an alert
interconnect_matrix · GB300 · 4 GPUs
GPU0 GPU1 GPU2 GPU3 GPU0 SELF NV14 NV18 NV18 GPU1 NV14 SELF NV14 SYS GPU2 NV18 NV14 SELF NV18 GPU3 NV18 SYS NV18 SELF
python3 pretrain_gpt.py · GPU 2 NUMA

Ran on CPUs 16-19, which are on NUMA 0 and not affine with this GPU.

fix: numactl --cpunodebind=1 --membind=1

GPU Straggler Detector

Find the straggler GPU that slows down training

One late GPU makes every other GPU wait. Zymtrace finds it, shows why, and correlates it to the corresponding GPU profiles.

The late GPU, per communicator How long its peers wait for it, per exchange and as a share of their time
Find the root cause Throttled clocks and NVLink errors are checked for you, and the profiles show the code when the hardware is clean
Correlated with its profiles The CUDA and CPU flamegraphs of the same window, down to the code behind the delay
Coverage

Inference, training, and everything underneath

Use Zymtrace to debug and optimize inference and training on the engines you already run.

Disaggregated inference, end to end

Metrics and profiles collected from the inference engines themselves, across prefill and decode, on heterogeneous accelerators. Drill from a dip in token throughput straight into the stall behind it.

vLLM vLLM
SGLang SGLang
NVIDIA TensorRT-LLM and Dynamo-Triton TensorRT-LLM Dynamo-Triton
prefill TTFT 84 ms healthy
decode ITL 11 ms bottleneck

Training and distributed runs

One execution flow across the CPU/GPU boundary, down to the exact GPU instruction.

execution flow · one stack self time
Python model.forward(tokens) 100%
Native aten::scaled_dot_product 93%
Launch cudaLaunchKernel(...) 85%
Kernel flash_attn_fwd_kernel 78%
SASS HMMA.16816.F32 62%
Stall stall_memory_dependency 41%

41% of GPU time waiting on memory, attributed to one instruction

Whole-system profiling, all major languages

Continuous profiles of all processes on the box, compiled and interpreted alike, with automatic symbolization of native and CUDA frames.

CUDA
ROCm
PyTorch
JAX Light Stroke
100% Code coverage
0 Code changes
0 Restarts

Recommendations built on top

Everything above feeds one ranked list: what to change, why it matters, and where to apply it.

HIGH SEVERITY recommendation · 1 of 16

Switch the KV cache to FP8

Decode is bandwidth-bound: 41% of GPU time stalls on memory dependency, not compute. An FP8 cache halves KV bytes per token and keeps more sequences resident, so batches grow instead of waiting.

cost $2,530/mo CO₂ 232 kg
1 vllm serve $MODEL --kv-cache-dtype fp8 2 add --calculate-kv-scales if uncalibrated
Autonomous optimization

Profile-guided agentic optimization

We enrich coding agents with perf data context from Zymtrace over MCP, so they find the bottleneck and open a pull request.

01
Pull Filters the fleet, then pulls GPU flamegraphs and inference metrics over MCP.
02
Correlate Cross-checks the CPU profiles for the same run to separate dispatch from compute.
03
Diagnose Names the hot frame, why it stalls, and what it costs in tokens/sec.
04
Fix and verify ↺ LOOP Applies the change, then re-profiles to prove the win.
coding agent · Zymtrace skills

MCP server

Flamegraphs, top functions, and GPU metrics exposed as MCP tools. Any MCP-capable agent can query production directly.

Zymtrace agent skills

Ready-made skills teach your coding agent the whole optimization workflow: rank consumers, read flamegraphs, interpret stall reasons, apply the fix.

Read about agent skills →

Subagents at fleet scale

Fan out specialized subagents to investigate many workloads in parallel. Each one returns an evidence-backed diagnosis and fix, not a guess.

Zero friction

Deploys into your existing stack, unchanged

No re-architecting. No code changes. The profiler drops into whatever you already run.

Kubernetes Kubernetes Helm, one command
Slurm Slurm HPC scheduler native
Multi-GPU Cluster-wide correlation
MIG Per-instance profiling
NVTX Your own code annotations
CUDA Graphs Full trace capture
Open-source DNA

Built by the team that donated the eBPF profiler to OpenTelemetry

With Zymtrace, we're extending that same low-level engineering to GPU-bound workloads, building a scalable profiling platform purpose-built for today's distributed, heterogeneous fleets.

deploy.sh
# zero code changes, no restarts. up in 5 minutes.
$ helm repo add zymtrace https://charts.zymtrace.com
$ helm install zymtrace zymtrace/profiler \
    --set gateway.url=$ZYMTRACE_GATEWAY

✓ profiler running fleet-wide
✓ CPU + GPU profiles streaming
✓ overhead <1% CPU · ~256MB RAM
FAQ

Frequently asked questions

Have another question? Email [email protected]

Yes. The Basic plan is free forever for CPU profiling on up to 5 machines, with no credit card required. To profile GPUs, talk to an engineer for a free trial GPU license.
Currently, only the self-hosted version is supported. If you're interested in a SaaS version, please contact Zymtrace support.
Zymtrace is a whole-system profiler for any application, not just GPU code. On machines with a supported accelerator (an NVIDIA or AMD GPU, or AWS Trainium), it also detects CPU operations that launch accelerator work and provides performance visibility into their interactions.
Zymtrace currently supports NVIDIA GPUs, AMD GPUs, and AWS Trainium, alongside CPUs. Chip support is expanding quickly. Contact Zymtrace support and we'll confirm coverage for your fleet.
Zymtrace is currently limited to Linux machines. It relies on eBPF, which isn't yet well supported on Windows.
The profiler uses at most 1% CPU in our testing, typically much less, and about 256 MB of RAM, a little more with Java workloads. This efficiency allows for 24/7 operation on most workloads without noticeably impacting the profiled systems. For particularly resource-sensitive environments, Zymtrace can be configured with lower sampling rates, providing valuable insights while further reducing its performance impact. The profiler profiles itself, so you can clearly see its overhead.

Get started now

Zymtrace is fully self-hosted. 5 minutes is all you need to get it up and running.