What is Large Language Model? — one analogy

1The analogy

If your neighborhood has just one bus line, you can only reach the stops along that one route. Add dozens of lines with tight interchange stations where they all meet, though, and everything changes. Nobody ever wrote down "how to get from here to there" for every possible pair of stops — yet by transferring across the map, you can reach a neighborhood you've never set foot in. A large language model is a transit map that has gotten this dense.

Each individual route is a connection the model picked up between one word and another, drawn from text it read. The more text it reads, the more routes appear, and the more places those routes intersect. Past a certain point, transfers alone get you to a destination nobody ever rode a direct line to.

There's a price for the bigger map, too. Laying and maintaining that many routes costs money and time in proportion to the scale.

2In detail

More routes means more places to reach

"Large" means three things grew at once. First, how much text it read — web pages, books, encyclopedias, public code, more than any one person could get through in a lifetime. Second, the number of adjustable values packed inside the model; each one is like the strength of a connection somewhere on the route map. Third, how much computation went into tuning those values.

Growing just one of the three barely helps. A map with countless routes and no ridership history is like not knowing where the transfer stations even are. Experiment after experiment has shown that performance keeps improving steadily when all three grow together in balance, and today's large models are built following that pattern.

What it actually does stays simple

No matter how big the transit map gets, a train still does one thing: move one stop at a time. A large language model works the same way. It looks at everything written so far, picks one next piece by probability, appends it, and looks again for the next one.

However long or logical the answer looks, this loop is all that's happening underneath. Text streaming across your screen is really pieces being produced one at a time — the whole answer isn't decided in advance and then dumped out.

Abilities appeared that weren't there before

A small model can string sentences together plausibly and not much more. But past a certain scale, models started doing things nobody had specifically trained them to do — pick up a pattern from two or three examples and continue it, work through a problem in stages, or organize a table in a format they'd never seen.

Abilities that show up suddenly as scale increases are called emergence. It's a bit like laying one more route and suddenly reaching clear across town. These abilities don't switch on and off cleanly, though, and how obvious they look can shift depending on how you measure them.

One more round of polishing after all that reading

A model that has only done all that reading isn't pleasant to use yet. Ask it a question and instead of answering, it might keep generating similar-sounding questions. All the routes are laid, but there's no announcement system yet.

So afterward, people feed it examples of "ask this way, answer that way," and adjust it again using human judgments of which answer is better. The conversational assistants people actually use have been through this extra polishing. Given the same size, how well a model went through this stage makes a huge difference in how it feels to use.

Bigger isn't only better

A large model ties up expensive computing hardware for a long time just to produce one answer. That means higher cost and slower replies — the bigger the transit network, the more it costs to maintain.

So real services split the work up. Small, purpose-built models handle fixed-format classification or short summaries, and the large model only gets called in for anything that requires real reasoning. The growing number of small models that run right on a phone follow the same logic.

3More precisely

A large language model stacks the transformer architecture very deep and trains it by repeatedly guessing the next piece across a massive amount of text. The adjustable values, called parameters, typically number in the billions to hundreds of billions. Training usually splits into two stages: pretraining across a huge volume of text first, then a stage that adjusts the model to follow instructions. There's also a fairly smooth relationship known between scale and performance, which lets teams calculate ahead of time what ratio of data to compute to use before training even starts.

The analogy breaks down in one place worth naming. A transit map is drawn by a person, so you can trace exactly which route goes where. The connections inside a model are numbers that settled into place on their own during training, and nobody can point to exactly where a given ability lives. A transit map also never takes you to a station that doesn't exist — a model can invent a destination that was never there and describe it convincingly, with no sign on the platform to give it away.

4Try it yourself

5Common misconceptions

It's easy to think a large language model looks up its answers from somewhere, but actually it isn't searching stored documents — it's just following connections shaped by training to keep picking the next piece.
It's easy to think making it bigger always makes it smarter, but actually the amount and quality of data and the computation have to keep pace, and skipping the polishing stage means the size doesn't pay off as much as it should.
It's easy to think the model remembers and learns from the conversation, but actually once training ends the model stays fixed — a conversation feels continuous only because the earlier turns get fed back in every time.

7One-line summary

In shortA large language model does the same simple job — picking one next piece — at a scale where the transit map has grown to cover the whole city.

Did this analogy help?

Spotted an error or have a better analogy? Suggest an edit · Last updated2026-09-02