About the role

We’re looking for an engineer to make machine learning training and inference faster, more efficient, and more reliable at the hardware–software boundary. This role welcomes specialists in GPU/accelerator kernels, ML compilers and accelerator backends, or framework/runtime and inference performance. You’ll apply deep systems knowledge to improve how ML workloads execute on modern hardware.

You don’t need to have worked across all three areas. We value deep technical ownership in at least one, an ability to reason from hardware and software behavior, and evidence that your work improves real systems.

Where you can make an impact

GPU and accelerator kernels: Design and tune compute primitives, memory layouts, fusion, parallelism, and numerical precision for high-performance execution.

ML compilers and accelerator backends: Improve lowering, code generation, scheduling, graph transformations, and hardware-specific execution for GPUs, TPUs, Trainium, or other accelerators.

Frameworks, runtimes, and inference performance: Optimize GPU backends, execution runtimes, serving systems, model operators, and end-to-end training or inference bottlenecks.

What you’ll do

Develop and optimize performance-critical components across GPU/accelerator kernels, ML compiler and code-generation pipelines, or framework and serving runtimes—based on your expertise.

Identify bottlenecks across compute, memory movement, scheduling, and execution; use profiling and measurement to guide optimization.

Improve the performance, efficiency, or capabilities of ML training and inference stacks, including their kernels, runtime components, and compiler pathways.

Work close to frameworks and serving systems such as PyTorch, JAX, vLLM, and SGLang, where relevant, to translate workload needs into low-level systems improvements.

Maintain correctness and numerical reliability while making performance tradeoffs; build clear benchmarks and validation approaches.

Collaborate with researchers, infrastructure engineers, and hardware-aware systems experts to scope problems, ship improvements, and see projects through to completion.

What we’re looking for

At least two years of post-graduation industry experience in GPU/accelerator kernels, ML compilers/backends, framework/runtime systems, inference performance, or comparably low-level infrastructure.

Deep implementation-level expertise in at least one relevant stack, such as CUDA/HIP, Triton, Pallas, NKI/Neuron, XLA, MLIR, TVM, PyTorch/JAX backends, TensorRT, vLLM, or SGLang. Experience with all of these is not expected.

Clear ownership of substantive kernel, compiler, backend, or runtime improvements—not only API usage. You can explain the design decisions, technical contribution, correctness checks, and measured impact or credible experimental evidence.

Strong understanding of hardware execution and performance fundamentals, including memory hierarchy, parallelism, latency, throughput, and performance profiling.

Ability to reason about numerical correctness, performance regressions, and the tradeoffs involved in optimizing ML workloads.

Evidence of delivering complex technical work collaboratively, from investigation through implementation and validation.

Especially relevant experience

Meaningful contributions to ML frameworks or inference/serving systems, such as PyTorch, JAX, vLLM, or SGLang, with clear ownership of a performance or systems outcome.

GPU software, TPU, Trainium, or other custom accelerator stacks; kernel libraries, compiler infrastructure, and chip-adjacent software.

Low-level systems engineering in high-performance infrastructure, even if your past work was not directly focused on large language models.

Research that translates into engineering results, especially work where you can clearly distinguish your own contributions and explain their practical impact.

What success looks like

You uncover important performance limitations, develop technically sound solutions, and deliver validated improvements with clear before-and-after evidence. You build trust through rigorous measurement, strong independent technical judgment, and effective collaboration across teams.