What Is a Large Language Model: A Probability Machine, Not an Expert

The big model trained itself on vast amounts of text to get good at “what comes next,” but don’t mistake it for an expert who understands the world. Get parameters, training, and inference straight, and you won’t mythologize it — and you won’t underestimate it either.

What it’s actually doing

Strip away the halo and the core task of a big model is plain: given the preceding text, predict the next most likely word, append it, and keep predicting. A whole answer is built word by word this way. What it learns is the probabilistic patterns of language. So what a big model “knows” is only language patterns, far from the truth about the world. A lot of what it says sounds reasonable simply because that kind of phrasing appears often in training text — not because it verified anything. Understand this and you won’t treat its words as authoritative conclusions.

What parameters are

Parameters (weights) are the massive numbers the model adjusts internally during training — where it “remembers” the patterns of language. More parameters mean the model can hold finer patterns and grasp complex semantics more delicately. Scale is one of the foundations of capability. But more parameters don’t necessarily mean smarter; data quality and training method matter too. Don’t blindly chase parameter count — at the same parameter size, clean data plus good methods pull ahead by a margin. Parameters are just the skeleton; what you feed and how you train decide what it grows into.

The two stages of training

Pre-training uses vast unlabeled text to teach the model the patterns of language and broad knowledge. This step is the heaviest on compute and the longest, and it’s “building the foundation.” After it, the model is like a well-read generalist without specialized training. Fine-tuning continues training on specific tasks or data to fit the model to concrete scenarios — answering by instructions, outputting in a format. The former handles the breadth of knowledge; the latter handles how well it fits tasks. Before investing, think clearly about which piece you’re missing.

How inference happens

After you ask, the model enters inference: predicting word by word from the preceding text, each step picking one candidate by probability and appending it, until it ends. Inference consumes compute, decides response speed and per-call cost, and is the moment the model “works.” Inference has tunable parameters, like temperature: low temperature is more certain and conservative, high temperature more divergent and creative. Different tasks pick different temperatures — push it down when writing code, open it up when brainstorming. The output’s personality follows this setting.

The boundary of what it doesn’t truly understand

A big model has no real senses or experience; it doesn’t “live” in the world, only processes text symbols. When it answers “which side does the sun rise from,” it relies on consensus in the corpus; it never actually observed it. Faced with real-world causality rarely seen in training, it confidently fabricates. So for things needing real verification, real-time facts, or professional judgment, treat it as “erudite but unreliable” and back it up with tools and human gatekeeping. Know the boundary and you won’t be steered wrong by its certainty at critical moments.

Where hallucination comes from

Hallucination is rooted in the very act of “predicting the next word”: the model prefers the high-probability continuation, even when it’s fabricated. When a question exceeds its reliable knowledge, it keeps spinning fluent but false answers because there’s no hard “I don’t know” switch. The remedy is external constraints: hook up retrieval so it answers from real material, draw red lines in the prompt, and demand source tracing for key conclusions. Understand the mechanism and you see why RAG and constraints can suppress it — instead of expecting the model to be self-disciplined.

Big models and small models

Same architecture, fewer parameters makes a small model, more parameters a big one. A big model has larger capacity and stronger capability but is expensive and slow; a small model is cheap, fast, and can run locally, but stumbles on complex tasks. Selection depends on how much “brainpower” the task needs. Distillation transfers big-model capability into a small model, so simple tasks don’t have to burn big resources. Understand this layer and you won’t throw the largest model at everything — you tier models by task complexity, and cost and experience stay balanced.

Its relationship with agents

A big model is an agent’s “brain,” responsible for understanding and deciding; the agent builds tools, memory, and workflows on top of it. Without a big model, an agent can’t think; without an agent, a big model is just a model that chats. Understand this and you see why an agent’s capability ceiling is bounded by the model, and why a big model alone isn’t enough — you also need engineering to turn its “ideas” into “actions.” One handles the thinking, the other handles the doing.

Three common misconceptions

Misconception one: the model understands the world; in fact it only understands language patterns. Misconception two: more parameters means smarter; in fact data and training matter just as much. Misconception three: everything it says is trustworthy; in fact it fabricates confidently. These three are really one thing: treat the big model as a “probabilistic next-word generator,” not an “omniscient expert” on a pedestal. With the boundary clear, using it comes with measure.

How to initially judge a model

Look at three things: measured performance on your own task, per-inference cost, and response latency. Leaderboard rankings are only a reference; actually running it on your scenario tells you whether it fits. Whether a model is good is decided by your data. Also look at controllability: private deployment, tunable temperature, safety rails. Factor these into selection instead of staring at parameter scale. Understand the model’s nature and selection stops being blind following.