Principal Engineer, Model Performance

Speedrun Talent Network; United States; Remote; USD 250,000 - 350,000; Full time

Benefits offered by this job

Stock options

Remote-first culture

Generous PTO

Parental leave

Company retreats

Job summary

Runware is seeking a Principal Engineer, Model Performance to own how fast and how cheaply every model runs across the fleet. You will lead kernel design, quantization strategies and parallelism optimizations, directing the Model Performance team, collaborating with Sonic Inference Engine, infrastructure, and hardware groups to deploy improvements on real traffic.

You will push for day-one performance of new models, select serving stacks, and build a scalable benchmarking/regression system to

Qualifications

• 10+ years in GPU, HPC or deep learning systems engineering with production inference experience.

Responsibilities

• Own inference performance end to end for the fleet: kernels, serving engines, model-level optimizations and benchmarks across image, video, audio, 3D and LLM workloads.
• Set the model performance roadmap and decide models, hardware and techniques to prioritize based on real traffic and cost.
• Write and tune CUDA kernels, fuse attention and MLP paths, bring up new quantization formats with quality maintained, and implement new parallelism/batching on multi-GPU nodes.
• Build the production deployment pipeline for newly released open models from weights to deployment in days.
• Shape the serving stack (TensorRT-LLM, vLLM, SGLang, diffusion/video pipelines) and contribute upstream where appropriate.
• Own benchmarking and regression systems with hardware-aware measurements integrated into CI.
• Collaborate with infrastructure and hardware teams to address GPU memory, storage and network bottlenecks that impact latency.
• Build and lead a performance team, hire senior engineers, and stay hands-on while guiding direction.
• Leverage AI tools for kernel search, profiling, benchmarking and documentation to scale team output.

Skills

CUDA kernels

GPU architecture

Python

C++

Leadership

Tools

TensorRT-LLM

vLLM

SGLang

Triton

PyTorch internals

Job description

Runware is the AI inference platform that builds and runs its own infrastructure, end to end. Our Sonic Inference Engine has served more than 20 billion requests for over 1 million developers and 500 million end users, with 400,000+ models behind a single integration, at up to 10x lower cost per token than traditional providers.

We are now building the AI Factory that runs it. The Sonic Inference Pod packs 1 MW of custom-designed compute into a 20-foot container with closed-loop, water-free cooling, sited wherever power exists. Pods are live in the US and Europe, and we are scaling to dozens of pods and tens of thousands of GPUs, all operated as one distributed fabric that reroutes traffic the moment a pod goes offline (announcement).

Every request that hits that fleet, whether it is an image, a video, a voice or a token stream, has to come back faster and cheaper than anyone else can serve it. Model performance is what makes that true. That is the job.

The role

As Principal Engineer, Model Performance, you will own how fast and how cheaply every model on Runware runs: diffusion and video generation, speech, 3D and LLMs, across 400,000+ models and tens of thousands of GPUs. You will set the performance roadmap, build the hardest pieces with your own hands, and build and lead the Model Performance team as it grows around you.

This is a principal-level role for someone who has led inference performance work at the frontier and still writes the kernel. You will decide where the next 2x comes from on a given model and hardware generation, whether that is a fused attention kernel, a better quantization recipe, speculative decoding, a smarter batching policy or a different parallelism layout, and then make it land in production on real traffic. You will work directly with the Sonic Inference Engine team, the infrastructure and hardware teams, and with NVIDIA and the open-source engine communities, and you will hire, mentor and lead the engineers who do this work alongside you.

Success means Runware serves a new open model at the Pareto frontier of latency and cost within days of its weights being released, our cost per request keeps falling with every hardware generation, and the team you have built can do this without you in the loop.

What you'll do

• Own inference performance end to end for the fleet: the kernels, the serving engines, the model-level optimizations and the benchmarks that prove them, across image, video, audio, 3D and LLM workloads on every GPU generation we run.
• Set the model performance roadmap. Decide which models, hardware and techniques get the team's attention and in what order, based on real traffic, real cost and what the next generation of pods will run.
• Do the hardest work yourself: write and tune CUDA kernels, fuse attention and MLP paths, bring up new quantization formats (FP8, FP4, INT4) with quality held, and get new parallelism and batching strategies working on multi-GPU nodes.
• Make new models fast on day one. Build the pipeline that takes a newly released open model from weights to a production-grade, optimized deployment in days, and keep closing that gap.
• Choose and shape the serving stack: TensorRT-LLM, vLLM, SGLang, custom diffusion and video pipelines, and the Sonic Inference Engine's own runtime. Decide what we adopt, what we fork and what we write ourselves, and contribute upstream where it pays.
• Own the benchmarking and performance regression system: reproducible, hardware-aware measurement of throughput, latency, cost and quality for every model we serve, wired into CI so that a regression never reaches a pod.
• Partner with infrastructure and hardware engineering on GPU memory, storage and network bottlenecks that show up as inference latency, and feed what you learn back into the next generation of servers and pods.
• Build and lead the team. Hire principal and senior engineers, set the bar for technical rigour, mentor the people on the team, and run it so that a very small group delivers performance across a very large model catalogue.
• Use AI to accelerate the work: automated kernel search and tuning, benchmark generation, profiling triage and documentation with LLM-based agents, so that the team's output grows faster than its headcount.

Requirements

What we're looking for

• 10+ years in GPU, HPC or deep learning systems engineering, with several of those optimizing inference performance for models in production at a company that runs them at scale.
• A track record of shipping performance, not just measuring it. You have taken a state-of-the‑art model from a reference implementation to the Pareto frontier of latency and cost on real hardware, and you know what breaks between the two.
• Deep, current, hands‑on CUDA and GPU architecture expertise: kernel design, memory hierarchy and occupancy, Tensor Cores, fused kernels, CUDA Graphs, NCCL, and the profilers (Nsight Systems and Compute) that show exactly where a microsecond goes.
• Real production experience with at least one major inference engine (TensorRT-LLM, vLLM, SGLang or similar) and with the techniques that define modern serving: continuous batching, paged KV cache, speculative decoding, prefill/decoding disaggregation, quantization and tensor, pipeline and expert parallelism.
• Fluent in Python and C++, comfortable in PyTorch internals, torch.compile and Triton, and happy to write the benchmark, the kernel and the CI job yourself rather than waiting for someone else to.
• Experience leading engineers: you have built or run a performance team, hired for it, set its technical direction and stayed hands‑on while doing so.
• You use AI to accelerate your own output every day, for kernel search, profiling analysis, benchmarking, documentation and code review, and you have a clear view of how a small team armed with these tools should operate differently.
• Comfortable owning outcomes in a fast‑moving, ambiguous environment, making decisions with incomplete information and being accountable for latency, cost and quality across hundreds of thousands of models.

Nice to have

• Diffusion and video generation performance: DiT and UNet pipelines, attention at long sequence lengths, step distillation, caching across denoising steps, LoRA hot‑swapping, and the loaders and samplers in ComfyUI, Diffusers or custom engines.
• Contributions to TensorRT-LLM, vLLM, SGLang, FlashAttention, CUTLASS, Triton, Dynamo or similar open‑source inference projects, or an open‑source project of your own that people run.
• Experience with Blackwell‑generation hardware (B200, GB200/GB300 NVL72), NVLink and NVSwitch topologies, and multi‑node inference over InfiniBand or RoCE.
• Mixture‑of‑experts serving: expert parallelism, expert placement and load balancing, and the memory and communication trade‑offs that come with them.
• Accuracy evaluation for optimized models: the harnesses, datasets and statistical discipline to prove a quantized or distilled model is as good as the original.
• Experience with non‑NVIDIA accelerators (AMD, TPU or custom silicon) and with porting an inference stack across them.
• Speech and audio model serving: streaming ASR and TTS with tight latency budgets.
• Published work, patents or talks on inference performance.

Benefits

What we offer

• A rare mandate: own inference performance for one of the largest model catalogues in the world, on hardware the company designs and operates itself, at a business whose margin is your work, with the GPU budget and backing to match.
• Meaningful stock options.
• We're a remote‑first collective, meeting in person twice a year to plan, brainstorm and celebrate wins. We keep core hours for collaboration and calls; outside those, you set your own schedule.
• Our release cycles are fast and intense, and they're followed by real downtime. We expect you to take it.
• Generous paid time off, including vacation, sick days and public holidays.
• Paid maternity, paternity and caregiver leave.
• Twice‑yearly company retreats in inspiring locations.