Member of Technical Staff - Inference Runtime

Modal; United States; Remote; USD 150,000 - 210,000; Full time

Job summary

Modal is seeking a systems engineer to advance the Inference Runtime team, building a production container runtime stack in Rust and Go. You will diagnose Linux and performance issues, shaping the architecture of Modal's container platform while collaborating with upstream maintainers like gVisor.

You will tackle fast startup, multi-GPU support, zero-copy data paths, memory-efficient snapshots, and performance tuning for Linux-based workloads across GPUs and RDMA-enabled setups.

Qualifications

• Strong Linux systems knowledge: processes, memory, filesystems, system calls, namespaces, cgroups.
• Experience building or debugging container runtimes, sandboxes, or low-level infrastructure.
• Proficiency in Rust or Go; interest in both languages.
• Experience profiling performance where memory movement and I/O are dominant.

Responsibilities

• Make container startup, checkpoint, and restore dramatically faster for large workloads.
• Build multi-GPU and accelerator-aware snapshotting with efficient memory handling.
• Design zero-copy and low-copy data paths between memory, filesystems, storage, and runtime.
• Optimize snapshot pipelines with parallel uploads and direct I/O.
• Improve container image and filesystem performance across EROFS, FUSE, and overlay FS.
• Extend sandboxed runtime to support new GPUs, drivers, and devices.
• Debug complex failures across system calls, VM, kernel behavior, and drivers.
• Roll out runtime changes across fleet with compatibility controls and observability.

Skills

Linux systems

Container runtimes

Rust

Go

Performance profiling

Kernel debugging

RDMA tech

Tools

gVisor

runsc

Linux kernel

Job description

About the roleModal's Inference Runtime team owns the container runtime stack used to run inference and training workloads across our fleet. We work at the boundary of Linux, containers, filesystems, storage, GPU drivers, and distributed systems.Our goal is to make demanding ML workloads start quickly, run efficiently, and remain securely isolated - whether they use a single GPU, hundreds of gigabytes of memory, or multiple GPUs connected with RDMA.We're looking for a systems engineer who enjoys working deep in the stack. You'll build production runtime infrastructure in Rust and Go, diagnose difficult Linux and performance problems, and help determine the architecture of Modal's container platform. You'll also work closely with maintainers of gVisor and contribute to the runtime itself when the right fix belongs upstream.

What you'll work on

• Make container startup, checkpoint, and restore dramatically faster for large inference and training workloads.
• Build multi-GPU and accelerator-aware snapshotting, including efficient handling of GPU memory and RDMA-enabled workloads.
• Design zero-copy and low-copy data paths between container memory, filesystems, storage, and Modal's runtime.
• Optimize large snapshot pipelines using techniques such as parallel uploads, direct I/O, incremental snapshots, and more efficient memory handling.
• Improve container image and filesystem performance across EROFS, FUSE, page caches, overlay filesystems, and remote storage.
• Extend our sandboxed runtime to support new GPUs, drivers, profiling tools, and device capabilities across NVIDIA and AMD hardware.
• Debug complex failures involving system calls, virtual memory, process lifecycle, kernel behavior, GPU drivers, and container isolation.
• Safely roll out runtime and kernel changes across a heterogeneous fleet using compatibility controls, scheduling constraints, feature flags, and observability.
• Work across the runtime, scheduler, storage, and GPU infrastructure-and take ambiguous production problems from investigation through deployment.

What we're looking for

• Strong Linux systems knowledge, particularly processes, virtual memory, filesystems, system calls, scheduling, namespaces, cgroups, and signals.
• Experience building or debugging container runtimes, sandboxes, Linux kernel, or similarly low-level infrastructure.
• Strong programming ability in Rust, Go, or another systems language, with an interest in becoming productive in both Rust and Go.
• Experience profiling and improving systems where memory movement, I/O, synchronization, or kernel interactions dominate performance.
• Comfort debugging across abstraction boundaries, from application behavior down through runtimes, drivers, and the kernel.
• An ability to turn loosely defined production problems into well-designed, reliable systems.
• A desire to own important infrastructure and work closely with both internal teams and customers.

Particularly relevant experience

Any of the following would be helpful, but none is required:gVisor, runsc, ru