Machine Learning Systems Engineer

Pivots Hiring; San Mateo (CA); On-site; USD 190,000 - 260,000; Full time

Job summary

Archetype AI, a Silicon Valley AI startup, seeks a senior software engineer to own the serving path for Newton and related multimodal models. The role centers on a Rust‑based inference stack, optimizing GPU utilization, and delivering low‑latency serving from kernel to GPU node.

You will collaborate with researchers to translate architectural changes into production workloads, implement profiling and observability, and advance high‑performance serving stacks with modern CUDA and GPU techniques.

Qualifications

• 6+ years in software engineering with ML systems or high‑performance GPU computing.
• Owns production serving path end to end, not just benchmarks.
• Expert in PyTorch with production deployments; can anticipate slowdowns.
• Strong CUDA or equivalent GPU depth and profiling experience.
• Rust or C++ alongside Python; comfortable in Linux production ops.
• Collaborates with researchers to translate architecture changes into serving tasks.

Responsibilities

• Build and own model nodes in the Rust inference runtime for loading, warmup, batching, streaming.
• Optimize GPU kernels, memory usage, mixed precision, and quantization.
• Design and maintain inference routing and streaming path to GPU nodes with latency/SLO considerations.
• Productionize checkpoints: export, compilation, parity evals, and rollout.
• Develop observability: latency histograms, GPU metrics, OOM traces.

Skills

ML systems

GPU computing

PyTorch

CUDA

Rust

C++

Python

Linux

Production ops

Profiling

Tools

Nsight

Triton

CUTLASS

TensorRT

Job description

**About Us**

At Archetype AI, we’re building the world’s first physical AI platform to bring artificial intelligence into the real world. Our foundation model, Newton, understands the physical world through objective sensor data and generates real-time insights into complex physical behaviors, from industrial machinery and systems to wearable devices and smart environments.

Formed by a high-caliber team from Google and backed by one of Silicon Valley’s most renowned venture funds, Archetype AI is at Series A and rapidly advancing its technology for the next big leap. This is a unique opportunity to join an exciting, fast-growing AI team based in the heart of Silicon Valley.

**About the Role**

You will own the serving path for Newton and related multimodal models. Much of our inference stack is Rust-native: model nodes in our agent runtime, built on Rust ML stacks (candle, Burn) with custom GPU kernels, plus the routing layer that streams real-time inference to GPU nodes. You will drive GPU utilization, numerical precision, and low-latency serving from the kernel up.

**What You’ll Own**

• Build and own model nodes in our Rust inference runtime: loading, warmup, batching, streaming, GPU memory pools.
• Optimize kernels and the GPU path: custom CUDA kernels, mixed precision, quantization, parity against research.
• Own inference routing and serving: streaming path API to GPU node, request batching, SLO-backed latency and cost.
• Productionize research checkpoints: export, compilation, quantization, parity evals, and rollout.
• Build the observability inference needs: latency histograms, GPU metrics, OOM signatures, replayable traces.

**Key Qualifications**

• 6+ years software engineering, several of them in ML systems, inference, or high-performance GPU computing.
• Has owned a production serving path end to end, not only benchmarked models.
• Expert in PyTorch with models shipped to production; knows what will be slow before the profiler runs.
• Strong CUDA or equivalent GPU depth: memory hierarchy, occupancy, Nsight or equivalent profiling.
• Rust or C++ alongside Python, Linux performance, production ops; ready to work in Rust daily.
• Works with researchers: can translate an architecture change into serving work.

**Nice to Have**

• Rust ML stacks: candle, Burn, or comparable GPU compute in Rust.
• Custom kernels and compiler stacks: Triton, CUTLASS, TorchInductor, TensorRT.
• Quantization and mixed precision in production with a numerical‑correctness suite.
• Multimodal, video, embedding or time-series serving, not only decoder‑only chat LLMs.
• High-performance serving stacks (vLLM, SGLang, TensorRT-LLM): continuous batching, paged KV cache.