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/decode 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 informati
Sourced from the a16z Speedrun talent network — apply on Speedrun.