The Core Idea: Many recent gains come from using models smarter, not just making them bigger: thinking longer at answer time, voting or verifying several attempts, distilling big models into small ones, and giving models tools and senses.
- Beginner: What Is Changing in LLMs Right Now?
LLMs are one of the fastest-moving areas of technology. This lesson covers ideas that are shaping current models rather than specific products, because product names change quickly while the underlying ideas last. Details here are simplified, and the field moves fast, so treat this as a map and not the final word.
| Trend | One-line idea |
|---|---|
| Reasoning and test-time compute | Let the model think longer or try several times on hard problems |
| Distillation and small models | Teach a small model to imitate a big one |
| Multimodal models | Understand text, images, audio and video together |
| Agents | Models that plan, use tools and act over many steps |
| Synthetic data | Use models to create training data for other models |
| New architectures | Alternatives and additions to plain attention |
Why it matters: Many of the biggest recent gains came not from making models larger but from using them smarter.
- Beginner: Thinking Longer Instead of Growing Bigger
For a long time, the main way to improve a model was to train a bigger one. A newer idea is to spend extra effort at answer time, called test-time compute. For hard questions such as math, logic and coding, the model can produce a long chain of reasoning, check its work, or try several solutions before answering.
Trade-off: More thinking means slower and more expensive answers, so it is best used for questions that really need it.
- Medium: Self-Consistency and Best-of-N
Two simple ways to use extra compute need no new training:
Both work because errors are usually scattered while the right answer tends to repeat. If a single answer is right with probability and the tries are independent, a majority vote gets more reliable as you add tries.
Real example from the code: If one answer is right 70% of the time, a majority vote of 21 tries is right about 97% of the time.
Limits: Votes help only when the model is usually right. If it is usually wrong in the same way, more tries just repeat the same mistake.
- Medium: Reasoning Models and Verifiable Rewards
Some recent models are trained to produce long reasoning traces before the final answer. A key idea behind them is reinforcement learning with verifiable rewards: for problems where the answer can be checked automatically (a math result, passing unit tests), the model gets a reward for correct final answers, and learns which kinds of reasoning lead to success, without needing human-labeled preferences for every step.
| Ingredient | Role |
|---|---|
| Problems with checkable answers | Give a trustworthy reward signal |
| Many sampled attempts | The model learns from its own successes and failures |
| Long reasoning before answering | Space to plan, check and correct itself |
| A cost limit | Controls how long the model may think |
Caution: Reasoning traces can be long, slow and costly, and a confident-sounding chain of thought is not proof that the answer is right. Verify important results.
- Advanced: Distillation, Multimodality and Beyond
Distillation trains a small student model to imitate a large teacher. Instead of learning only from hard labels, the student matches the teacher's full probability distribution, which carries rich hints about how similar the options are. A temperature softens the teacher's probabilities to make these hints easier to see.
| Direction | What it is | Why it matters |
|---|---|---|
| Distillation | A student copies a teacher's outputs | Small, cheap models that keep much of the quality |
| Multimodal | One model reads text, images and audio | Assistants that can see and listen |
| Agents | Plan, call tools, observe, repeat | Models that finish tasks, not just answer |
| Synthetic data | Models generate training examples | More data where real data is scarce (needs careful filtering) |
| State-space and hybrid models | Fixed-size memory mixed with attention | Efficient long sequences |
| On-device models | Small quantized models on phones and laptops | Privacy and no network needed |
- Visual Explanation: Spending Compute Where It Counts
The figure contrasts spending compute during training with spending it at answer time, then shows how majority voting improves with more tries.
Click to see when voting does not helpCompare ▼
Part 1 compares the two places to invest effort. Part 2 uses the numbers computed in the code for a model that is right 70% of the time. Open the bar to learn when voting fails.
- Python Implementation: Majority Voting, Best-of-N and Distillation
This script calculates the accuracy of majority voting and best-of-N sampling with exact probabilities, then computes the soft teacher probabilities used in distillation and measures how close three different students are to the teacher with a KL distance.
import numpy as npfrom math import comb # 1. Self-consistency: ask several times, take the majority answerdef majority_correct(p, n): # chance that more than half of n independent answers are right (n is odd) return sum(comb(n, k) * p ** k * (1 - p) ** (n - k) for k in range(n // 2 + 1, n + 1)) for p in [0.6, 0.7]: print("single answer right", p, "-> majority of 5:", round(majority_correct(p, 5), 3), "| of 21:", round(majority_correct(p, 21), 3)) # 2. Best-of-n with a verifier: chance that at least one of n samples is correctfor p in [0.1, 0.3]: print("one sample right", p, "-> best of 8 (perfect verifier):", round(1 - (1 - p) ** 8, 3)) # 3. Distillation: the student learns from the teacher's soft probabilitiesdef softmax(z, T=1.0): z = np.array(z) / T e = np.exp(z - z.max()) return e / e.sum() teacher_logits = [4.0, 2.0, 0.5]for T in [1.0, 3.0]: print("teacher probabilities at temperature", T, "->", np.round(softmax(teacher_logits, T), 3)) def kl(p, q): return float(np.sum(p * np.log(p / q))) teacher = softmax(teacher_logits, 3.0)for name, logits in [("student far off", [0.0, 0.0, 0.0]), ("student close", [3.5, 1.8, 0.7]), ("student identical", teacher_logits)]: print(name.ljust(18), "-> KL distance to teacher:", round(kl(teacher, softmax(logits, 3.0)), 4))A majority of 21 tries lifts a 70% model to about 97%, but a 60% model only to about 83%. Best-of-8 with a perfect checker lifts a 30%-per-try model to about 94%. For distillation, a higher temperature spreads the teacher's probabilities, and the KL distance shrinks to zero as the student matches the teacher.
Interactive Knowledge Check
Key Points
The Big Picture
Think longer + check more + shrink what you learned + give models tools = better answers at lower cost
This series took you from tokens and attention to serving, evaluation and the frontier. The same fundamentals will help you understand whatever comes next.
Up Next: You have finished the LLM series. A good next step is to build a small project that combines prompting, structured outputs, retrieval and evaluation, then apply these ideas in RAG and AI Agents.