LLM Model Training Residency

Join the Hippocratic AI

LLM Model Training Residency

You are exceptional at software.
Now build the models behind it.

Subho Mukherjee, PhD,
Co-founder & Chief Science Officer

DURATION

6 months

COMMITMENT

Part-time · ~10 hrs/week

FORMAT

Structured · after hours

Hippocratic AI is launching the LLM Model Training Residency: a six-month, structured program for experienced software engineers who want to make the move into LLM Model Training Residency — without leaving their career behind to do it.

This is not a lecture series, nor a reading group. You will fine-tune models, run experiments on production hardware, ship a real capstone project, and work directly with a senior ML engineer who built the systems you are learning.

Why We Built This

There is a gap at the center of the AI talent market right now. On one side: applied scientists who came up through ML research or graduate programs. On the other: the far larger population of experienced software engineers who are technically excellent — but were not trained on transformers, fine-tuning, or LLM infrastructure.

These engineers are not behind because they lack ability. They are behind because they lacked access. The right curriculum. The right mentors. The right infrastructure to learn by doing — not on toy problems, but on systems that matter.

At Hippocratic AI, we train models. Every release cycle, our engineers pretrain, fine-tune, and ship models that talk to real patients about real clinical decisions. We have the production hardware, the internal codebase, and the senior ML engineers to run a program that actually moves the needle — not in theory, but in six months.

We built this residency because we believe great engineers can make this transition on the job, with the right structure. And because the engineers who are best positioned to do groundbreaking work in LLM Model Training for healthcare are often the ones who already know how to build things that scale, stay up, and ship.

What Makes This Different

01

You learn on production systems — not course material.

Your work runs on our NVIDIA H200/B300 cluster, against our internal models, datasets, and benchmarks. The same hardware the model org uses every release cycle.

02

Your mentor built what you are learning.

Residents learn directly from the senior scientists in Hippocratic AI’s model org — the team behind Polaris, our speech models, and our safety infrastructure. Regular office hours give you time with them, plus a shared group session with the full cohort.

03

The curriculum is structured, not self-directed.

Three phases over six months: LLM foundations, applied work on our internal codebase, and a capstone project against a real open problem. You are not figuring it out alone on nights and weekends.

04

The path to an ML engineering role is clear.

The program ends with a capstone demo and a focused technical conversation — not a full interview loop. On successful completion of the program, the transition to an ML engineering role follows.

How the Program Works

The residency runs twice a year. It asks for roughly 10 hours per week outside your primary role, structured across curriculum, mentorship, and project work.

Three Phases

PHASE 1 MONTHS 1–2
LLM Foundations
Deep learning fundamentals, transformer architecture, LLM basics — tokenization, attention, pretraining objectives — and evaluation methodology. You build shared vocabulary with the model org before writing a line of training code.
PHASE 2 MONTHS 3–4
Applied LLM Work at HAI
Fine-tuning, distillation, and LoRA traced through Polaris and our speech models on the actual codebase. You run experiments on the H200/B300 cluster, evaluate against our internal benchmarks, and learn to read model behavior the way the model org does.
PHASE 3 MONTHS 5–6
Capstone Project
A real project scoped with your mentor: a safety classifier, an ASR improvement, a Polaris pipeline optimization, or a new benchmark. You ship something that runs on production systems and present it to the team.

Who Should Apply

This program is built for a specific person: a strong, experienced software engineer who has spent years building production systems and is ready to move into LLM Model Training — but needs the structure, mentorship, and infrastructure to get there.

You are the right candidate if:

You have 3+ years of professional software engineering experience and ship production code
You understand systems at depth — performance, reliability, scale
You have been watching the LLM world and want in — and are willing to commit ~10 hours a week for six months to get there
You do not need prior ML experience. That is what the residency teaches.

The one thing that does not change: your day job. The residency runs alongside your primary role, not instead of it.

What You Walk Away With

Engineers who complete the program and pass the capstone assessment can apply to an open ML engineering role at Hippocratic AI.

You will have fine-tuned models, run experiments on production hardware, and shipped a real project on the same infrastructure the model org uses daily. You will have worked directly with senior ML engineers at one of the most technically ambitious healthcare AI companies in the world.

And you will have done it without pausing your career to get there.

Hippocratic AI Residency Programs

Hippocratic AI now offers two distinct residency tracks — one for engineers starting their careers, one for engineers ready to evolve theirs.

AI Agent Deployment Engineering Residency — for early-career engineers and recent graduates who want to work at the cutting edge of AI deployment in healthcare. Full-time, in-person, rotational.
LLM Model Training Residency — for experienced engineers who want to move into LLM work. Part-time, structured, after-hours, with a clear path to an ML engineering role.

Apply to the Next Cohort

Applications open ahead of each cohort, and we run two cohorts per year.

Join as a software engineer first — after six months, you’re eligible to apply to the next residency cohort.

FAQ

1. What is the LLM Model Training Residency?

It’s a six-month, structured program for experienced software engineers who want to move into LLM Model Training without leaving their career behind. Rather than a lecture series or reading group, you fine-tune models, run experiments on production hardware, ship a real capstone project, and learn directly from the senior ML engineers who built the systems you’re studying.

2. How much time does it require, and how is it structured?

The residency asks for roughly 10 hours per week over six months, on a part-time, after-hours basis. That time is split across curriculum, mentorship, and project work. It runs alongside your primary role, not instead of it — your day job doesn’t change.

3. Do I need prior machine learning experience?

No. Prior ML experience is not required — that’s exactly what the residency teaches. The program is built for strong software engineers who were never trained on transformers, fine-tuning, or LLM infrastructure but are ready to make the move.

4. Who is the right candidate?

You’re a good fit if you have 3+ years of professional software engineering experience and ship production code, understand systems at depth (performance, reliability, scale), have been watching the LLM world and want in, and are willing to commit ~10 hours a week for six months.

5. What will I actually work on?

The curriculum runs in three phases over six months:

Phase 1 (Months 1–2) — LLM Foundations: deep learning fundamentals, transformer architecture, LLM basics like tokenization, attention, and pretraining objectives, plus evaluation methodology.
Phase 2 (Months 3–4) — Applied LLM Work: fine-tuning, distillation, and LoRA traced through Polaris and our speech models on the actual codebase, with experiments on the cluster and evaluation against internal benchmarks.
Phase 3 (Months 5–6) — Capstone: a real project scoped with your mentor — a safety classifier, an ASR improvement, a Polaris pipeline optimization, or a new benchmark — that you ship on production systems and present to the team.

6. What infrastructure will I have access to?

Your work runs on Hippocratic AI’s NVIDIA H200/B300 cluster, against our internal models, datasets, and benchmarks — the same hardware the model org uses every release cycle. You learn on production systems, not toy problems or course material.

7. How does mentorship work?

Every resident learns directly from the senior ML engineer from Hippocratic AI’s model org — the team behind Polaris, our speech models, and our safety infrastructure. Regular office hours give you time with them, plus a shared group session with the full cohort.

8. What happens when I complete the program?

On successful completion of the program and the capstone assessment, engineers can apply to an open ML role at Hippocratic AI. The program ends with a capstone demo and a focused technical conversation, not a full interview loop.

9. How large are the cohorts and how often does it run?

The residency runs twice a year. The small cohort size supports close mentorship and a shared group session across the whole group.

10. How is this different from the AI Agent Deployment Engineering Residency?

Hippocratic AI offers two distinct tracks. The AI Agent Deployment Engineering Residency is for early-career engineers and recent graduates — full-time, in-person, and rotational. The LLM Model Training Residency is for experienced engineers moving into LLM work — part-time, structured, and after-hours, with a clear path to an ML engineering role.

11. When can I apply, and when does the cohort start?

We run two residency cohorts each year. You join Hippocratic AI as a software engineer first; after six months in that role, you’re eligible to apply to the next residency cohort.

12. Why run a residency instead of self-teaching?

Self-teaching LLM Model Training on nights and weekends rarely produces production-grade engineers. The residency commits curriculum, senior mentorship, real infrastructure, and six months to the transition — because that’s what it actually takes. You’re not figuring it out alone.