← All speakers

Bio, Work & Ideas

Daniel Han

Conference affiliation: Co-founder · Unsloth · 2026

Daniel Han is the co-founder of Unsloth, the open-source AI company he founded with his brother Michael to make powerful models easier to fine-tune, compress, and run locally. His work addresses a practical constraint on open AI: useful models often exceed ordinary developers’ hardware budgets, while subtle implementation errors can quietly undermine their accuracy.

From GPU acceleration to Unsloth

Han’s earlier projects included sciblox, a toolkit for easier data science and machine learning, and an investigation into reversing Markov chains. He and Michael also developed HyperLearn, an earlier machine-learning software project.

At NVIDIA, Han worked on GPU-accelerated machine learning in the RAPIDS ecosystem. His article about accelerating t-SNE described improvements to the dimensionality-reduction algorithm in RAPIDS cuML, including substantial speedups under specific testing conditions.

The brothers launched Unsloth in December 2023 to accelerate language-model fine-tuning and reduce memory consumption without requiring new hardware. Unsloth joined Y Combinator’s Summer 2024 batch and expanded into reinforcement learning, model distribution, quantization, and local AI workflows.

  • Open-model debugging: Han identified failures in Gemma, Llama, and Phi models that stemmed from activation-function discrepancies, incorrect numerical precision, duplicate beginning-of-sequence tokens, incompatible chat templates, untrained token embeddings, and collisions between padding and end-of-sequence tokens. Such defects can cause invalid gradients, degraded fine-tuning, or endless generation. His technical walkthrough of open-model failures treats tokenization, training, inference, and export as one interconnected system.
  • Correct gradient accumulation: Daniel and Michael traced discrepancies between accumulated small-batch training and equivalent full-batch training to incorrect loss normalization across sequences of different lengths. Their gradient-accumulation investigation addressed a mathematical error embedded in widely used training workflows and supported related improvements with Hugging Face.
  • Asynchronous gradient checkpointing: The brothers’ long-context training research describes moving selected intermediate activations into system memory without unnecessarily blocking GPU execution. This approach makes longer fine-tuning contexts feasible while limiting additional runtime.
  • Dynamic quantization: Han’s compression strategy preserves sensitive layers or weights at higher precision while aggressively compressing less sensitive components. Unsloth’s dynamic four-bit research demonstrates why uniform compression can damage a vision-language model’s interpretation even when the resulting file is smaller. In an August 2026 update, Han reported one-bit Qwen variants capable of running in 8 GB of RAM, with retained accuracy measured through Unsloth’s internal testing.
  • Reward design and benchmark reliability: Han emphasizes that reinforcement learning depends on meaningful reward functions, adequate exploration, and verification that reflects the intended task. His reasoning-model workshop connects supervised fine-tuning, GRPO, parameter-efficient adaptation, and low-memory inference. His work on reward hacking and evaluation examines how weak tests, contaminated benchmarks, misleading timing measurements, and incorrect intermediate reasoning can produce impressive scores without corresponding improvements.

Han’s goal is democratizing capable local AI through software that preserves useful behavior while reducing the memory, hardware, and expertise required to adapt advanced open models.

Talks by Daniel Han

5 talks

Key ideas

Scroll to read ↓

Daniel Han explains how supervised fine-tuning, verifiable rewards, GRPO, careful sampling, selective quantization, and compiler optimizations fit together—and why reward design and efficiency matter more than algorithmic mystique.

  • Use an instruction-tuned checkpoint or a small supervised priming stage before GRPO when a base model cannot reliably produce rewardable outputs; otherwise training can remain stuck with zero useful signal. 36:30 ↗ 1:28:41 ↗ 2:30:16 ↗
  • GRPO replaces a separately trained value model with statistics from multiple responses to the same prompt, while RLVR can replace a learned reward model with directly verifiable reward functions. 48:04 ↗ 1:16:16 ↗ 1:17:23 ↗ 1:50:17 ↗
  • Treat reward design as the central engineering problem: combine correctness, format, and partial-credit checks carefully, and remember that a correct final answer does not prove the reasoning trace is valid. 1:30:35 ↗ 1:35:50 ↗ 1:37:47 ↗ 2:09:03 ↗ 2:11:18 ↗
  • Maintain sampling diversity, balance rollout count against memory and compute, and monitor answer-correctness rewards rather than assuming that improved formatting means the model has learned the task. 1:23:41 ↗ 1:24:44 ↗ 2:14:42 ↗ 2:17:56 ↗ 2:19:00 ↗
  • Apply dynamic quantization selectively: inspect activation and weight quantization errors, preserve sensitive layers at higher precision, and avoid assuming that only large-magnitude weights matter. 2:32:48 ↗ 2:35:13 ↗ 2:36:18 ↗ 2:37:19 ↗
  • Distinguish demonstrated techniques from unresolved questions: Han treats whether reinforcement learning creates genuinely new capabilities, how far models should move from their starting checkpoint, and how subjective rewards scale as open or uncertain issues. 41:59 ↗ 47:10 ↗ 1:21:10 ↗ 1:39:58 ↗ 2:23:44 ↗

Key ideas

Scroll to read ↓

Making a model fit is only the beginning: selective precision, architecture-aware evaluation and runtime compression determine whether local intelligence remains useful.

  • How much intelligence fits on your computer?
    0:21 ↗
  • From open reasoning to local agents
    4:41 ↗
  • Precision belongs where errors matter
    11:36 ↗
  • Benchmark the allocation, then examine the format
    14:46 ↗
  • A benchmark score does not describe the whole deployment
    17:51 ↗
  • A large quantized model or a small native model?
    21:41 ↗
  • Local demand changes what gets built
    24:21 ↗
  • Creating the checkpoint is the easy part
    28:54 ↗
  • New architectures invalidate old shortcuts
    32:30 ↗
  • The next compression targets are runtime state and computation
    37:27 ↗
  • How do you find a trustworthy modified model?
    43:22 ↗

Key ideas

Scroll to read ↓

From Gemma’s activation function to Llama 3’s special tokens, reliable fine-tuning depends on preserving the model’s assumptions through training, conversion and inference.

  • The activation function is part of the model
    0:38 ↗
  • Insert the beginning-of-sequence token once
    2:15 ↗
  • A chat template can reference untrained embeddings
    3:24 ↗
  • Do not mask away the instruction to stop
    5:31 ↗
  • Carry the training template into deployment
    6:50 ↗
  • Train sensitive parameters carefully, and offload asynchronously
    8:38 ↗
  • Choose sequence length and memory settings from the data
    10:34 ↗
  • Give LoRA enough capacity without exhausting memory
    12:15 ↗
  • Turn a CSV row into a repeatable conversation
    13:44 ↗
  • Accumulate gradients, then check the inference prompt
    15:29 ↗
  • Export the model and the configuration that makes it usable
    16:11 ↗

Key ideas

Scroll to read ↓

An activation mismatch can make two implementations of the same model disagree. Daniel Han’s workshop follows the computation from tokenization through transformer kernels, numerical debugging, fine-tuning, and export.

  • A model is more than its weights
    1:34 ↗
  • Read the conditions behind GPU performance
    9:46 ↗
  • Separate training choices, implementation changes, and memory costs
    15:30 ↗
  • Read a decoder as a sequence of operations
    23:07 ↗
  • Invent a tokenizer, then find its limitations
    30:10 ↗
  • The next token must remain unseen
    36:27 ↗
  • Learn token vectors and align their targets
    44:12 ↗
  • Vocabulary size and embedding width are different dimensions
    52:25 ↗
  • A causal mask lets training positions share one pass
    58:50 ↗
  • Follow attention through its matrix shapes
    1:02:23 ↗
  • Normalization has a short formula and a real backward pass
    1:07:18 ↗
  • Position encoding is only part of usable context
    1:09:54 ↗
  • A rotation makes the RoPE derivative easier to see
    1:20:52 ↗
  • MLP variants change how features are mixed
    1:23:11 ↗
  • Cross-entropy reductions can be computed in chunks
    1:30:55 ↗
  • Find the equations inside modeling_llama.py
    1:35:04 ↗
  • The final head reconnects the network to its targets
    1:49:44 ↗
  • Compare Gemma at corresponding layers
    1:57:25 ↗
  • Precision belongs to the computation
    2:08:09 ↗
  • Repair position precision, then check the remaining differences
    2:24:55 ↗
  • Configuration and adapter placement can change behavior
    2:34:49 ↗
  • The chat template must survive the trip to inference
    2:40:43 ↗
  • Export the model, then test the representation it receives
    2:47:44 ↗

Key ideas

Scroll to read ↓

A model’s apparent capability depends on its precision, serving stack, agent harness, and evaluator. Daniel Han follows those dependencies from task horizons to kernel optimizations that cheat.

  • Can the model actually finish the task?
    0:26 ↗
  • A task horizon changes when cheating counts
    2:31 ↗
  • Rising scores, shrinking usable context
    6:08 ↗
  • What sustains the next doubling?
    11:28 ↗
  • How open models catch up
    20:26 ↗
  • Spend precision where it matters
    27:56 ↗
  • Throughput is only valuable when the answers work
    38:49 ↗
  • The harness and provider are part of the model you experience
    46:58 ↗
  • The evaluator can be wrong too
    1:02:58 ↗
  • Competing audits and tiny parsing mistakes
    1:12:16 ↗
  • Generate varied tasks with explicit checks
    1:19:07 ↗
  • Capability measurements become access questions
    1:26:07 ↗
  • Scaling through software and numerical representation
    1:37:51 ↗
  • Try the compiler before writing a kernel
    1:44:42 ↗
  • Fusion, specialization, and memory traffic
    1:48:59 ↗
  • Rewards provide a narrow teaching signal
    1:59:44 ↗
  • A correct answer can reward a wrong step
    2:05:17 ↗
  • Optimizing the timer instead of the multiplication
    2:09:42 ↗
  • Correct during validation, cached during timing
    2:13:51 ↗
  • Inspect what a faster kernel actually does
    2:16:35 ↗

References