Large Language Models: Capabilities, Scaling, and Limits

When OpenAI described GPT-3 in 2020, the headline was not a new architecture. It was a 175-billion-parameter model that could pick up a task from a few examples typed into its prompt, with no retraining at all. Since then, large language models have been scaled, instruction-tuned, and taught to reason step by step, and each change moved a different set of benchmark numbers. This article follows the evidence: what scale bought, which techniques turned capacity into skills, and which failures have survived every upgrade so far.

Key Takeaways

• Scale is predictable: Language-model loss falls as a smooth power law in model size, data, and compute, a pattern reported over more than seven orders of magnitude in 2020.
• Size is not the whole recipe: A 70-billion-parameter model trained on more data beat a 280-billion-parameter one, and a 1.3-billion-parameter model tuned with human feedback was preferred to a 175-billion-parameter one.
• Prompting changed the interface: Few-shot examples and step-by-step reasoning unlocked abilities that were present but hard to elicit.
• Failures are systematic: Hallucination, one-directional recall, and uneven use of long inputs are documented in peer-reviewed or preprint studies and have not been eliminated by scale.
• Benchmarks need context: A score depends on the test setting, the comparison group, and whether the model has effectively seen the questions.

What a large language model is

A large language model (LLM) is a neural network trained to predict the next token in a sequence of text, where a token is a word or word fragment. The "large" refers to the number of parameters, the adjustable numbers inside the network that are tuned during training. After training on a huge amount of text, the model can generate new text by predicting one token at a time and feeding each prediction back in.

An analogy helps. Imagine an apprentice who has read a very large library but never been allowed to look anything up afterward. Asked a question, the apprentice answers from memory, in whatever style the question suggests. The apprentice is often right, sometimes confidently wrong, and has no built-in way to tell which is which. That is a fair first picture of an LLM, and it explains most of what follows. For the mechanics, see how large language models work.

Almost every modern LLM uses the Transformer architecture introduced in the 2017 paper Attention Is All You Need. That paper's contribution was a design built entirely on attention, which let training run in parallel and made very large models practical. The reported translation results (28.4 BLEU on English-to-German and 41.8 on English-to-French) were state of the art at the time, and the English-to-French model trained in 3.5 days on eight GPUs. How transformers pay attention to words explains the mechanism with worked examples.

The scaling recipe: three ingredients, one smooth curve

In 2020, Kaplan and colleagues reported that a language model's cross-entropy loss, its average error in predicting the next token, follows a power law in three quantities: model size, dataset size, and training compute. The trends held across more than seven orders of magnitude. They also found that architectural details such as network width or depth matter little within a wide range, and that larger models are more sample-efficient, meaning they learn more from each training example.

What does a power law mean in practice? Here is a deliberately simplified illustration, not a measured result. Suppose each tenfold increase in compute cut a model's remaining error by a fixed fraction, say 20 percent. Then going from 1 unit of compute to 10 would take error from 1.00 to 0.80, 100 units would reach 0.64, and 1,000 units would reach about 0.51. Each step costs ten times more than the last and buys a smaller absolute improvement, but the improvement is reliable. That reliability is what let labs plan very expensive training runs.

Why a bigger model is not always the better buy

The Kaplan results suggested spending a fixed compute budget mostly on bigger models. A 2022 follow-up changed that advice. Hoffmann and colleagues trained a 70-billion-parameter model called Chinchilla using the same compute budget as the 280-billion-parameter Gopher, but with about four times more training data. Chinchilla outperformed Gopher, GPT-3, and other larger models on a wide range of downstream tasks, including an average 67.5 percent on the MMLU benchmark, more than seven points above Gopher.

The practical rule they drew was that model size and training tokens should scale together: for every doubling of model size, the number of training tokens should also double. In effect, many earlier models were undertrained, like a large engine fed too little fuel. Scaling laws explained, from Kaplan to Chinchilla covers the arithmetic in more depth.

Model	Parameters	Training data	Why it matters
GPT-3 (2020)	175 billion	About 300 billion tokens	Showed few-shot learning from prompts
Gopher	280 billion	Baseline for Chinchilla	Large model with comparatively less data
Chinchilla (2022)	70 billion	About four times Gopher's data	Beat Gopher and GPT-3 at the same compute as Gopher
InstructGPT (2022)	1.3 billion	GPT-3 fine-tuned with human feedback	Preferred by raters to 175-billion-parameter GPT-3

Sources: Brown et al. (2020); Hoffmann et al. (2022); Ouyang et al. (2022).

From fine-tuning to prompting: few-shot learning

Before GPT-3, the standard way to use a pre-trained language model was fine-tuning. BERT, released in 2018, was pre-trained on unlabeled text and then adapted to each task by fine-tuning with a single extra output layer. It reported state-of-the-art results on eleven NLP tasks, but each new task still meant new labeled data and a new training step.

The GPT-3 paper argued for a different interface. Describe the task in text, perhaps include a few worked examples, and let the model continue. This is called few-shot or in-context learning. The model's weights do not change; the examples live only in the prompt. In the paper's tests, the 175-billion-parameter model reached 100.0 percent accuracy on two-digit addition and roughly 80 percent on three-digit addition in the few-shot setting. The paper also notes that GPT-3's few-shot learning still struggled on some datasets, a caveat that is easy to lose in later retellings.

How far in-context learning can go

A striking recent example comes from the Gemini 1.5 report. The authors gave the model a grammar manual for Kalamang, a language with fewer than 200 speakers, and reported that it learned to translate from English to Kalamang at roughly the level of a person who studied the same material. The same report describes near-perfect retrieval, above 99 percent, up to at least 10 million tokens of context.

Nobody fully understands why in-context learning works. One hypothesis is that, during training on varied text, the network picks up general procedures for inferring a task from examples. Another is that attention matches the new query against the examples and copies their pattern. Both are plausible and neither is settled. What is settled is that the behavior is real but bounded, and that how much a model can hold in its context window is only part of how well it uses that context.

Instruction following: why alignment mattered as much as size

A raw pre-trained model completes text. Ask it a question and it may continue with a list of similar questions, because that is what text often does. Turning completion into assistance was the contribution of instruction tuning with human feedback.

In the InstructGPT paper, Ouyang and colleagues fine-tuned GPT-3 on human demonstrations and then on human preference rankings. Human raters preferred outputs from the 1.3-billion-parameter InstructGPT model to outputs from the 175-billion-parameter GPT-3, a model more than 100 times larger. The tuned models also improved on truthfulness and produced less toxic output, with minimal performance regressions on public NLP datasets, though the authors note they still make simple mistakes.

The technique is reinforcement learning from human feedback (RLHF). People rank candidate answers, a reward model learns to predict those rankings, and the language model is trained to produce answers the reward model scores well. Imagine training a chef by having diners rank dishes, then teaching a food critic to predict the diners' rankings, and finally having the chef cook for the critic. It works, with a known weakness: the chef can learn to please the critic rather than the diners. RLHF, RLAIF, and DPO compared discusses variants designed to reduce that gap.

Emergence: sudden skills or a measurement artifact?

As models grew, some abilities seemed to appear abruptly. In 2022, Wei and colleagues defined an ability as emergent if it is not present in smaller models but is present in larger ones, and noted that such abilities cannot be predicted by extrapolating from smaller models.

In 2023, Schaeffer, Miranda, and Koyejo argued that much apparent emergence comes from the choice of metric. They found that discontinuous scoring, where an answer is either exactly right or wrong, creates sudden-looking jumps, while linear or continuous metrics applied to the same outputs show gradual, predictable improvement. Their analysis covered a mathematical model, GPT-3-family tasks, a BIG-Bench meta-analysis, and vision tasks.

The two papers do not cleanly contradict each other. A model can improve smoothly in underlying competence while only crossing the threshold of "usable" on a specific task at a specific size. For a product team, the threshold is what matters. For a researcher forecasting future systems, the smooth curve is the more useful object. When a headline says a skill "emerged," the sensible follow-up is to ask how the skill was scored.

Reasoning: spending tokens to think

One of the most practical discoveries about LLMs is that how you ask matters as much as what you ask. Chain-of-thought prompting, introduced in a January 2022 paper by Wei and colleagues, includes worked examples with intermediate steps in the prompt. Prompting a 540-billion-parameter model with eight such examples reached state-of-the-art accuracy on GSM8K, a benchmark of grade-school math word problems, surpassing even fine-tuned GPT-3 with a verifier. GSM8K itself was introduced by Cobbe and colleagues and contains about 8,500 problems.

Why does writing out steps help? Each generated token is one forward pass through the network, a fixed amount of computation. A problem that needs ten dependent steps cannot be solved reliably in one pass, but it can be solved across ten passes if the intermediate results are written down and reused. The scratch paper is the computation. Compare how people multiply two-digit numbers: mentally in one go they often fail, on paper they rarely do. See AI reasoning and chain of thought for more.

Search beats a single pass

A single left-to-right chain can still go wrong at step one and never recover. The Tree of Thoughts paper lets a model explore several partial solutions and backtrack. On the Game of 24, where four numbers must be combined with arithmetic to reach 24, GPT-4 with chain-of-thought prompting succeeded on about 4 percent of tasks, while Tree of Thoughts reached about 74 percent.

Spending compute at answer time

The same idea scales up. Snell and colleagues studied test-time compute, the computation spent when answering rather than when training. They reported that a compute-optimal strategy that allocates test-time compute adaptively per prompt improved efficiency by more than four times over a best-of-N baseline, and that in a matched-compute comparison it could outperform a model 14 times larger, but only on problems where the smaller model already had a non-trivial success rate. The DeepSeek-R1 paper reported that reinforcement learning alone, without human-labeled reasoning examples, could improve reasoning and produce behaviors such as self-reflection and verification. For how these systems work, see test-time compute explained.

Technique	What it changes	Documented result
Few-shot prompting	Examples in the prompt	GPT-3: 100.0 percent on two-digit addition
Chain-of-thought	Intermediate steps written out	State-of-the-art on GSM8K with a 540-billion-parameter model
Tree of Thoughts	Exploration and backtracking	Game of 24: about 4 percent to about 74 percent
Test-time compute	More inference spent per problem	More than 4x efficiency over best-of-N; can beat a 14x larger model on easier problems

Code and mathematics

Code is a favorable domain for LLMs. It is structured, there is a vast amount of public examples, and correctness can be checked by running it. OpenAI's GPT-4 technical report lists a 67.0 percent pass rate on HumanEval, a benchmark of short Python programming tasks, against 48.1 percent for GPT-3.5. The same report shows how uneven that skill is: on LeetCode problems GPT-4 solved 31 of 41 easy ones, 21 of 80 medium ones, and 3 of 45 hard ones.

The productivity picture is more nuanced than benchmark pass rates. In a controlled experiment, Peng and colleagues asked developers to implement an HTTP server in JavaScript as quickly as possible. Those using GitHub Copilot finished 55.8 percent faster than the control group, with effects varying across participants. That is one task in one language, and it should not be generalized to all programming, but it is the kind of randomized evidence that vendor claims rarely supply.

Mathematics is harder because a single wrong step invalidates a result. Models do better when they can offload exact calculation to a tool, for example by writing a short program that a computer then runs, or when answers can be checked by a verifier. The GSM8K paper's approach of generating many candidate solutions and picking the one a trained verifier ranks highest is an early example of this pattern: let the model propose, and let something more reliable judge.

Knowledge: what the MMLU numbers show

MMLU, introduced by Hendrycks and colleagues in a 2020 benchmark paper, covers 57 tasks including elementary math, US history, computer science, and law. The questions are multiple-choice with four options, so random guessing scores 25 percent. At the time, most models performed near chance, and the largest GPT-3 model improved on chance by almost 20 percentage points on average. The authors also reported uneven performance across subjects and poor awareness of the models' own errors.

The scores climbed quickly after that. In the figures reported by each model's authors, Chinchilla averaged 67.5 percent, GPT-3.5 scored 70.0 percent, and GPT-4 scored 86.4 percent in a 5-shot setting. Those numbers come from different papers with different prompting setups, so treat the sequence as a rough trajectory rather than a controlled comparison.

A rising MMLU score means a model answers more exam-style questions correctly. It does not mean the model understands each subject the way a specialist does. For how to read such numbers, see how AI benchmarks measure machine intelligence.

Where capabilities break

The most useful part of the research literature is the catalog of repeatable failures. These are not rare glitches; each has been measured.

Hallucination

A hallucination is a fluent statement that is false. Kalai and colleagues argued in 2025 that hallucinations arise because training and evaluation reward guessing over admitting uncertainty. Models become optimized to be good test-takers, and a test-taker who is unsure does better, on average, by guessing than by leaving a blank. Their proposed fix is to change how widely used benchmarks are scored so that confident errors cost more than honest uncertainty. Why AI hallucinates facts gives the full picture, and retrieval-augmented generation is the most common mitigation.

One-directional recall

Berglund and colleagues documented what they called the reversal curse: a model trained on "A is B" does not automatically learn "B is A." GPT-4 correctly answered questions such as "Who is Tom Cruise's mother?" 79 percent of the time but only 33 percent of the time for the reverse, "Who is Mary Lee Pfeiffer's son?" Knowledge in an LLM is stored in a way that is sensitive to the direction in which it appeared in text.

Uneven use of long inputs

Liu and colleagues found that performance is often highest when relevant information is at the beginning or end of the input and drops significantly when it is in the middle, even for models designed for long contexts. The Gemini 1.5 retrieval results above show that retrieving a planted fact can be near-perfect, which is a narrower task than reasoning over every part of a long document. The two findings measure different things.

Weak calibration

The MMLU authors reported poor awareness of the models' own errors, and the hallucination analysis above gives a reason: if confident guessing is rewarded, confidence stops carrying information. A user cannot treat the tone of an answer as a signal of its reliability.

Failure	Measured evidence	Practical consequence
Hallucination	Training and grading reward guessing (Kalai et al., 2025)	Verify claims that matter
Reversal curse	GPT-4: 79 percent forward, 33 percent reverse	Ask in more than one direction
Lost in the middle	Accuracy drops for mid-context information	Put key facts at the start or end
Search-heavy tasks	Game of 24: about 4 percent with chain-of-thought	Use search or tools for planning

Alignment and safety: what remains open

Alignment techniques reduced harmful and untruthful output, but they have documented limits. The InstructGPT authors reported improvements in truthfulness and reduced toxicity, yet noted the models still make simple mistakes. RLHF depends on human raters who disagree and make errors, and on a reward model that is itself an imperfect proxy. When a system is optimized hard against a proxy, it can find outputs that score well without being good.

Researchers are attacking the problem from two sides. One is better training signals, which is what RLHF variants try to provide. The other is looking inside the network to understand what it computes, an approach called interpretability, explained in mechanistic interpretability. A broader overview of the open questions is in AI safety and alignment explained.

Are LLMs superhuman?

An earlier version of this article used the word "superhuman" in its title. The evidence supports a narrower statement. On breadth, no single person matches an LLM's coverage of languages, programming languages, and academic subjects, and on specific exams such as MMLU, models have reached 86.4 percent in GPT-4's reported results. But there is no consensus that scores like these represent expert-level performance across the fields tested, and the failures above show that high averages coexist with simple errors a person would not make.

A helpful way to hold both facts: LLMs are broad and shallow in unpredictable places. A strong generalist who occasionally invents a citation, forgets that a relationship runs both ways, and loses a detail from the middle of a long document is useful, but is not a replacement for an expert's judgment. The Microsoft Research team that tested an early GPT-4 in Sparks of Artificial General Intelligence reached a similar mixed conclusion: performance close to human level on many tasks and a suggestion of early, incomplete general intelligence, alongside a need for a paradigm beyond next-word prediction to go further.

How to judge a capability claim

Capability claims are cheap, and tests are not. A few habits make claims easier to assess.

1. Look for the test setting. Zero-shot, few-shot, chain-of-thought, and tool-assisted scores are different measurements.
2. Check who ran it. Authors' own results and independent evaluations can differ.
3. Ask about the comparison group. Percentile claims depend on who the model is compared with.
4. Watch for contamination. If test questions appeared in training data, the score overstates ability. This is hard to audit when training data is unpublished.
5. Prefer the continuous metric. As the emergence debate shows, all-or-nothing scoring can manufacture drama.

The topic of systematic evaluation has its own explainer: LLM evaluation and evals. For adapting a model to your own task rather than judging a general one, see fine-tuning LLMs.

The takeaway

The central finding about large language models is not that they are intelligent or that they are not. It is that capability follows an unusually regular curve in compute, data, and parameters, and that training methods and prompting decide how much of that capacity you can use. Chinchilla, InstructGPT, chain-of-thought, and test-time compute each showed a way to get more from the same raw material.

The failures follow a pattern too. They come from how models are trained and graded: next-token prediction that rewards plausible text, benchmarks that reward guessing, and context mechanisms that favor some positions over others. Until training and evaluation change, those failures should be expected rather than treated as surprises. The sensible stance is to use LLMs where errors are cheap to catch and to design checks where they are not.

Frequently Asked Questions

Q: Why can LLMs do things they were never explicitly trained to do? A: Next-token prediction on very large, varied text forces a model to learn many regularities, including how tasks are described and solved in writing. Few-shot prompting then supplies the task description at run time. GPT-3 showed this in 2020, and later work such as the Gemini 1.5 Kalamang example suggests it can extend to rare languages given enough context.

Q: Are LLMs reasoning, or pattern matching? A: The evidence is mixed. Chain-of-thought and Tree of Thoughts results show that models solve multi-step problems far better when allowed to write out or search over intermediate steps. Yet documented failures such as the reversal curse show that what they store is sensitive to how it was phrased in training. Reasoning-like behavior is real, and so are the limits.

Q: Can scaling alone solve hallucination? A: Larger and better-trained models generally hallucinate less on benchmarks, but the 2025 analysis by Kalai and colleagues argues the problem is tied to training and grading incentives that reward guessing. On that account, scale alone would not remove it; changing how models are evaluated and trained to express uncertainty would also be needed.

Q: Is a bigger model always better? A: No. Chinchilla, at 70 billion parameters, outperformed the 280-billion-parameter Gopher by training on about four times more data with the same compute budget. InstructGPT at 1.3 billion parameters was preferred by raters to 175-billion-parameter GPT-3. Data, training method, and alignment all affect quality.

Q: What is the difference between few-shot prompting and fine-tuning? A: Few-shot prompting places examples in the prompt, and the model's weights do not change, so the effect disappears when the prompt does. Fine-tuning updates the weights using training examples, so the change persists. BERT-style models were typically fine-tuned per task, while GPT-3 popularized the few-shot approach.

Q: How reliable are benchmark scores? A: They are reliable as measurements of a specific test under specific conditions, and unreliable as general claims. Scores shift with prompting setup, scoring metric, and whether the questions appeared in training data. Compare scores only when the settings match, and prefer independent evaluations to vendor-reported ones.

---

Sources:

• Vaswani, A., et al. (2017). "Attention Is All You Need." https://arxiv.org/abs/1706.03762
• Devlin, J., et al. (2018). "BERT: Pre-training of Deep Bidirectional Transformers." https://arxiv.org/abs/1810.04805
• Brown, T., et al. (2020). "Language Models are Few-Shot Learners." https://arxiv.org/abs/2005.14165
• Kaplan, J., et al. (2020). "Scaling Laws for Neural Language Models." https://arxiv.org/abs/2001.08361
• Hoffmann, J., et al. (2022). "Training Compute-Optimal Large Language Models." https://arxiv.org/abs/2203.15556
• Ouyang, L., et al. (2022). "Training language models to follow instructions with human feedback." https://arxiv.org/abs/2203.02155
• Wei, J., et al. (2022). "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." https://arxiv.org/abs/2201.11903
• Wei, J., et al. (2022). "Emergent Abilities of Large Language Models." https://arxiv.org/abs/2206.07682
• Schaeffer, R., et al. (2023). "Are Emergent Abilities of Large Language Models a Mirage?" https://arxiv.org/abs/2304.15004
• Cobbe, K., et al. (2021). "Training Verifiers to Solve Math Word Problems." https://arxiv.org/abs/2110.14168
• Yao, S., et al. (2023). "Tree of Thoughts." https://arxiv.org/abs/2305.10601
• Snell, C., et al. (2024). "Scaling LLM Test-Time Compute Optimally." https://arxiv.org/abs/2408.03314
• DeepSeek-AI. (2025). "DeepSeek-R1." https://arxiv.org/abs/2501.12948
• Hendrycks, D., et al. (2020). "Measuring Massive Multitask Language Understanding." https://arxiv.org/abs/2009.03300
• OpenAI. (2023). "GPT-4 Technical Report." https://arxiv.org/abs/2303.08774
• Peng, S., et al. (2023). "The Impact of AI on Developer Productivity: Evidence from GitHub Copilot." https://arxiv.org/abs/2302.06590
• Gemini Team, Google. (2024). "Gemini 1.5." https://arxiv.org/abs/2403.05530
• Berglund, L., et al. (2023). "The Reversal Curse." https://arxiv.org/abs/2309.12288
• Liu, N., et al. (2023). "Lost in the Middle." https://arxiv.org/abs/2307.03172
• Kalai, A., et al. (2025). "Why Language Models Hallucinate." https://arxiv.org/abs/2509.04664
• Bubeck, S., et al. (2023). "Sparks of Artificial General Intelligence." https://arxiv.org/abs/2303.12712

---

Read next:

• DeepSeek R1 Explained
• How AI Models Are Trained: The Full Pipeline Explained
• Why AI Benchmarks Can Be Misleading