Researchhot

Member of Technical Staff

Also hired as: MTS · Research Engineer · AI Lab Engineer

The flat title behind every frontier lab — and the highest engineering bar in the industry.

US salary · 2026

$300k – $850k+ total comp

Equity-heavy and rising with seniority; senior researchers and infra leads clear the top of this band. Estimates from public postings — lab comp moves fast and varies wildly by team.

Typical background

Strong systems or ML engineers, PhD researchers, and prolific open-source contributors — most arrive with years of visible, verifiable technical work rather than one specific credential.

This roadmap

5 stages · 25 nodes

5 proof-of-work checkpoints

What is a Member of Technical Staff?

Member of Technical Staff is the deliberately flat title frontier labs give almost everyone technical — a convention borrowed from Bell Labs. At Anthropic, OpenAI, Mistral, xAI, Thinking Machines, and SSI, the person training models, the person building the inference stack, and the person shipping Claude Code may all carry the same three words on their badge. The title signals a culture: small, high-trust teams where hierarchy is minimal and impact is the only ladder. When people say they want to work at a lab, an MTS role is usually what they mean.

The role exists in its current shape because labs stopped being pure research shops. Training frontier models is now an industrial effort: data pipelines, distributed training infrastructure, inference serving, evals, safety systems, and product surfaces all need world-class engineers — and a large share of MTS hires in 2026 are engineers, not PhD researchers. Labs compete for a small pool of people who can operate at their bar, which is why compensation looks like nothing else in tech, and why the interview process filters as hard as it does.

What makes MTS distinct from every other role on this page: you build what everyone else consumes. Agent engineers orchestrate models through an API; you are on the other side of that API, deciding how the model behaves, how fast it serves, and what ships around it. The realistic paths in are narrower but more concrete than people assume — serious open-source contributions to ML infrastructure, published research replications, evals work, or exceptional systems engineering. Credentials help less than a public track record the lab can verify.

What you'll actually do

Launch, babysit, and debug large training runs — including the 3am kind of debugging.
Build and scale data pipelines that filter, dedupe, and mix training corpora.
Design and run evals on model checkpoints to decide what ships and what gets rolled back.
Optimize inference: KV-cache management, batching, quantization, and serving latency.
Ship product surfaces on top of the models — the coding agents and APIs the world uses.
Replicate external research fast enough to decide whether the lab should care.
Write design docs and internal research notes that other MTS actually read.
Carry on-call for training or serving infrastructure where an hour of downtime is enormous.

This role fits you if

You read papers and reproduce them instead of just retweeting them.
You are happy three levels down the stack — collectives, kernels, memory bandwidth — when the problem demands it.
You have merged PRs in serious ML infrastructure, or you want that more than a title.
A flat title on a small, extremely strong team sounds like a feature, not a slight.
You can write both a Triton kernel and a clear one-page memo about it.

The toolbox

PythonPyTorchJAXCUDA / TritonDistributed training (FSDP, tensor parallel)Transformer internalsTokenizersEval harnessesvLLM / inference servingKubernetes / SlurmWeights & BiasesRust or Go (infra)

The roadmap — 5 stages, 25 nodes

Stage 1

Foundations That Actually Matter

Weeks 1–8

Build a transformer with your own hands. Labs do not hire people who only know the API surface.

Transformers from scratchCore

Implement attention, an MLP block, and a training loop in raw PyTorch — nanoGPT-style, no libraries doing the thinking. You should be able to explain why each matrix multiply exists.

How LLMs Actually Work Attention Is All You Need

The math that pays rentCore

Linear algebra, probability, and optimization at the level training actually uses: gradients, softmax stability, learning-rate schedules, why loss curves look the way they do. Skip the proofs; keep the intuition.

Tokenizers and data hygieneCore

Train a BPE tokenizer, inspect what it does to code and non-English text, and learn why dataset dedup and mixture ratios move benchmarks more than architecture tweaks.

A paper a weekElective

Read the canon — attention, scaling laws, RLHF, Constitutional AI — one per week, with notes on what you would test. The goal is taste: knowing which claims are load-bearing.

AI Glossary

Checkpoint: train a small LM end to end✓ Checkpoint

Pretrain a 10–50M parameter transformer on a public dataset with a single GPU. Publish the repo with loss curves, sample outputs, and a writeup of every bug that cost you a day.

Stage 2

Systems and Scale

Months 2–4

Most MTS openings are systems roles. GPU performance and distributed training are the actual moat.

The GPU mental modelCore

Learn memory bandwidth vs compute, kernel launches, and profiling with real tools. Write one fused Triton kernel and measure the speedup — the exercise teaches more than a course.

Distributed trainingCore

Understand data, tensor, and pipeline parallelism, then run a real multi-GPU FSDP job — rented A100s are fine. Debug one NCCL failure and you will understand why labs pay for this skill.

Inference engineeringCore

KV cache, continuous batching, quantization, speculative decoding. Serve an open model with vLLM, load-test it, and explain where the latency goes.

A systems languageElective

Pick up Rust or Go well enough to write a data-pipeline tool. Lab infra teams increasingly want one systems language next to Python.

Checkpoint: reproduce a known result✓ Checkpoint

Reproduce a published result at small scale — a nanoGPT speedrun time, a scaling curve across three model sizes, or an inference benchmark. Publish your numbers next to the originals and explain any gap.

Chinchilla scaling laws

Stage 3

Post-Training and Evals

Months 4–7

Post-training and evaluation are where labs hire hardest right now — and where outsiders can realistically build proof.

The post-training stackCore

SFT, RLHF, DPO — what each actually optimizes and what each breaks. Run SFT and DPO on an open model with TRL so the acronyms become muscle memory.

Fine-Tuning Fundamentals Hugging Face TRL docs

Eval literacyCore

Why benchmarks saturate, how contamination happens, why a 2-point delta might be noise. Build a small harness and run the same eval five times to see the variance yourself.

Why Traditional Testing Fails

LLM-as-judge and human dataCore

Rubric design, judge bias, and when human labels are non-negotiable. Labs run enormous human-data operations; understanding that machinery is a hiring signal.

LLM as Judge

Interpretability basicsElective

Replicate a small interpretability result — induction heads or a toy sparse autoencoder. Optional, but it is a strong differentiator for safety-focused labs.

Checkpoint: fine-tune with proof✓ Checkpoint

Take an open-weights model, fine-tune it with LoRA + DPO on a task you define, and ship a before/after eval suite of 100+ prompts proving the delta. Repo, weights, writeup.

LoRA & QLoRA

Stage 4

Public Proof of Work

Months 6–10

Labs hire people they can verify. Open source and replications are the résumé that gets read.

Contribute to serious ML infraCore

Pick one repo the field depends on — vLLM, transformers, PyTorch, a major eval harness — and work its issue tracker until you have merged PRs. Maintainers of key infra get recruited by labs constantly.

Replication as portfolioCore

Take a recent paper, replicate it, and write up what reproduced and what did not. Honest negative results build more credibility than cheerleading.

Write in publicCore

Technical posts that show taste — a training-bug postmortem, a profiling deep-dive. One excellent post outperforms twenty shallow ones.

Live on the frontier toolsElective

Use Claude Code or an equivalent agent daily and understand the product surface labs are actually shipping. Product-side MTS roles exist, and most candidates ignore them.

What Is Claude Code Claude Code course

Checkpoint: a cited artifact✓ Checkpoint

Land three merged PRs in a serious ML repo plus one replication writeup that strangers actually read — shared by the original authors, cited in a discussion, or picked up by a newsletter.

Stage 5

The Lab Gauntlet

Months 9–12

Applications, referrals, and an interview loop designed to say no. Play it like a campaign, not a lottery ticket.

Target the right doorCore

Residency programs, infra roles, evals teams, and product engineering all lead to MTS. Applying only to 'research scientist' is the most common self-inflicted rejection.

The interview barCore

Expect hard coding rounds, ML breadth, systems design for training or serving, and a deep discussion of your own work. Practice explaining your checkpoint projects in five minutes and in forty-five.

Referrals via work, not networkingCore

Your OSS contributions and replications are the referral engine — the maintainers and authors you worked with know people at labs. Ask after you have shipped, not before.

Adjacent on-rampsElective

Inference providers, eval companies, and lab-adjacent startups hire at a slightly lower bar and feed talent into labs. Two years there beats five years of cold applications.

Checkpoint: run a full application cycle✓ Checkpoint

Five-plus tailored applications across labs and residencies, a portfolio doc mapping your proof-of-work to each team, and at least one final-round loop. Treat every rejection debrief as data for the next cycle.

Build your portfolio

Nobody hires a Member of Technical Staff off a certificate. They hire off proof. Ship these and put them where people can click them:

A small LM trained from scratch

Pretrain a 10–50M parameter transformer on a public dataset with one GPU. Repo with loss curves, sample outputs, and a writeup of every bug that cost you a day.

Proves: You understand training below the API surface — the baseline every lab conversation starts from.

A fused kernel with receipts

One Triton kernel replacing a slow op, profiled before and after, with the memory-bandwidth math explaining the speedup published alongside the code.

Proves: You can work three levels down the stack — the skill most MTS systems openings actually screen for.

A paper replication, numbers side by side

Reproduce a published result at small scale — a scaling curve across three model sizes or a nanoGPT speedrun — with your numbers next to the originals and an honest account of any gap.

Proves: You verify claims instead of retweeting them, which is the daily posture of lab work.

A fine-tune with before/after proof

LoRA + DPO on an open-weights model for a task you define, with a 100+ prompt eval suite demonstrating the delta. Repo, weights, writeup.

Proves: You treat post-training as an engineering loop with evidence — the area labs are hiring hardest.

A benchmark or eval contribution

Extend a serious eval harness or publish a small benchmark others can run — variance measured across five runs, contamination handled, cases documented.

Proves: You can build the instruments labs use to decide what ships — rare, verifiable, and in demand.

Merged PRs in infrastructure the field runs on

Three-plus nontrivial merged PRs in vLLM, transformers, PyTorch, or a major eval harness — issues worked in public, reviews survived, features shipped.

Proves: Maintainers labs already trust have reviewed your code — verification no resume line can match.

Position your profile

Headline formula

“I do [training infra / inference / post-training] work in public: [N] merged PRs in [vLLM / PyTorch], a replication of [paper], and a [X]M-param LM trained from scratch.”

Resume bullets to earn

Pretrained a [X]M-parameter transformer from scratch on [dataset]; published the repo, loss curves, and debugging postmortem ([N] GitHub stars).
Replicated [paper or result] within [X]% of published numbers; writeup shared by [the original authors / a major ML newsletter].
Wrote a fused Triton kernel cutting [op] latency [X]% versus the PyTorch baseline, with a public profiling deep-dive.
Landed [N] merged PRs in [vLLM / transformers / PyTorch], including [fix or feature] shipped in release [version].
Fine-tuned [open model] with LoRA + DPO, moving [task] win rate from [X]% to [Y]% on a 100+ prompt eval suite I built.

Where to be visible

The issue trackers of vLLM, transformers, PyTorch, and major eval harnesses — sustained contribution there is the single highest-signal channel for lab recruiting.
Public replications: a repo plus writeup for every paper you reproduce, honest negative results included. Original authors share these, and lab engineers read them.
Contribute cases and fixes to open eval suites — small surface area, high visibility, and exactly what post-training teams look for.
One deep technical post a quarter — a training-bug postmortem, a profiling deep-dive — over weekly content. Lab engineers read depth, not cadence.
Open-research communities — EleutherAI and similar Discords, paper-discussion threads — where lab staff actually hang out. Contribute analysis, not takes.

What interviews actually test

Coding at a genuinely high bar: hard implementation problems, fast, in plain Python. Labs calibrate above standard big-tech screens — practice past the point of comfort.
ML systems depth: transformer internals, why runs diverge, KV-cache math, how you'd debug a slow multi-node job. If you built the portfolio, this is revision, not cramming.
Research discussion of recent papers: which claims are load-bearing, what you would test next. Your paper-a-week notes are the prep; the interview is reading them back.
Design rounds for training or serving systems — 'serve this model at [X] QPS' — where your own reproduction and profiling numbers prove you're not improvising.
A deep walkthrough of your own work: rehearse a five-minute and a forty-five-minute version of every portfolio piece. The panel probes what you personally did; vagueness is fatal.

Who's hiring

AnthropicOpenAIGoogle DeepMindMistralxAIThinking Machines LabSafe Superintelligence (SSI)Meta Superintelligence LabsAllen Institute for AI (Ai2)

Free courses that map to this role

Course 04 — Agentic AI Engineering

The systems layer around models — RAG, evals, security — is exactly the literacy lab engineering interviews probe.

Course 01 — Vibe Coding using Claude Code

Labs ship agentic products; knowing the frontier tooling as a power user makes you faster at every stage of this roadmap.

FAQ

What does Member of Technical Staff actually mean?

It is a deliberately flat title, borrowed from Bell Labs, that frontier labs give nearly everyone technical — researchers, infra engineers, and product engineers alike. It signals that the org chart is shallow and status comes from impact, not title inflation. Read the team description in the posting, not the title, to know what the job actually is.

Do I need a PhD to get an MTS role?

Not for the majority of openings. Research-scientist tracks still skew heavily PhD, but infra, evals, and product MTS roles hire strong engineers on demonstrated work. A public record — merged PRs, replications, shipped systems — substitutes for the credential; nothing substitutes for the bar.

How hard is it really to get into Anthropic or OpenAI?

Brutally hard — labs reject the overwhelming majority of applicants, including genuinely strong ones, and the loops are long. The counterweight is that labs now hire hundreds of engineers a year across many teams, so the door is narrow but not sealed. Multiple application cycles are normal, not a verdict on you.

What's the difference between MTS and Research Scientist?

At some labs there is no difference — everyone is MTS. Where both titles exist, Research Scientist implies setting research direction and usually a publication record, while MTS spans everything from training infra to product. The pay bands overlap far more than outsiders expect.

Does open-source work actually get you hired at labs?

Yes, and it is the most reliable outsider path. Maintainers and heavy contributors to infrastructure labs depend on — inference engines, training frameworks, eval harnesses — get recruited because their work is already verified in public. Three meaningful merged PRs beat any cover letter.

Start building, today

Every stage above maps to free lessons on this site. No signup, no paywall — open the first course and ship your first checkpoint this week.

Browse the courses →