How LLMs Work: From Tokens to Attention and Alignment

Large Language Models (LLMs) are often described as systems that “understand language.” In practice, they are probabilistic sequence models built on top of the Transformer architecture, designed to map input text into structured representations and generate coherent outputs token by token.

To understand how LLMs work, we need to unpack several layers: what these models actually optimize, how text is converted into tokens and vectors, how Transformers model context through attention, why hallucinations occur, and how techniques like RLHF align model behavior with human expectations.

1. The Nature of LLMs: Probabilistic Sequence Modeling

At a high level, an LLM generates text by predicting what comes next. Given a sequence of tokens, it assigns probabilities to possible continuations and selects one based on a decoding strategy.

Formally, the model learns a conditional probability distribution:

P(w_t | w_1, w_2, …, w_{t-1})

During training, the objective is to minimize the difference between predicted tokens and actual tokens in large text corpora, typically using cross-entropy loss. This means the model is not learning facts explicitly—it is learning statistical regularities in language.

This distinction is critical. The model does not retrieve knowledge in a symbolic sense; it reconstructs plausible continuations based on learned distributions. What appears as “understanding” is an emergent property of large-scale pattern learning.

2. From Text to Tokens: Representation Learning

Before any computation happens, raw text must be transformed into a numerical format. This begins with tokenization, where text is split into smaller units.

Unlike simple word-level splitting, modern LLMs rely on subword tokenization methods such as Byte Pair Encoding (BPE) or WordPiece. These methods strike a balance between vocabulary size and flexibility, allowing the model to handle rare words and morphological variations efficiently.

Each token is then mapped to a dense vector through an embedding matrix:

token → vector in R^d

These embeddings are not arbitrary. Over training, they organize into a space where semantic and syntactic relationships are encoded geometrically. Words used in similar contexts end up with similar vectors.

Since Transformers do not inherently encode sequence order, positional information is injected through positional encodings. Without this step, the model would treat a sentence as an unordered set of tokens.

3. Transformer Architecture: The Computational Backbone

The Transformer is the core architecture enabling modern LLMs. Its key innovation is replacing recurrence with attention, allowing all tokens in a sequence to be processed simultaneously.

A standard Transformer layer consists of:

Multi-head self-attention
Feed-forward neural networks (FFN)
Residual connections
Layer normalization

Each layer refines token representations by integrating contextual information from other tokens. As data flows through multiple layers, representations become increasingly abstract, capturing not just word meaning but relationships, dependencies, and higher-level structure.

This layered transformation is what enables LLMs to move from raw tokens to something resembling contextual understanding.

4. Attention Mechanism: Modeling Context

When processing a sentence, not all words contribute equally to meaning. The attention mechanism allows the model to dynamically weight the importance of different tokens.

Each token is projected into three vectors: Query (Q), Key (K), and Value (V). The interaction between tokens is computed through a scaled dot-product:

Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V

This operation produces a weighted combination of values, where the weights reflect how relevant each token is to the current one.

In practice, multiple attention heads are used in parallel. Each head can capture different types of relationships—syntactic structure, semantic similarity, or long-range dependencies. The outputs are then combined, allowing the model to integrate multiple perspectives on the same sequence.

Attention effectively acts as a routing mechanism, determining how information flows across the sequence.

5. From Representation to Generation

Once input tokens are processed through the Transformer stack, the model produces logits—unnormalized scores over the vocabulary. These are converted into probabilities via the softmax function.

Text generation proceeds iteratively:

Compute probability distribution over next token
Select a token (greedy, top-k, or nucleus sampling)
Append the token to the sequence
Repeat

The choice of decoding strategy significantly affects output behavior. Deterministic methods improve consistency, while stochastic sampling increases diversity but may introduce errors.

This iterative process explains why LLMs can generate long, coherent text while still occasionally drifting or contradicting themselves.

6. Why Hallucinations Occur

One of the most discussed limitations of LLMs is hallucination—the generation of content that is fluent but incorrect.

This behavior follows directly from the training objective. The model is optimized to produce likely sequences, not verified truths. When faced with uncertainty or incomplete knowledge, it will still generate the most probable continuation.

Several factors contribute to hallucinations:

Lack of grounding in external knowledge sources
Ambiguity or gaps in training data
Overgeneralization of learned patterns

From a mathematical perspective, the model selects:

argmax P(token | context)

rather than evaluating factual correctness.

This makes hallucination an inherent property of probabilistic generation, not merely a failure mode.

7. LLMs and AI Tools: From Models to Systems

In real-world applications, LLMs rarely operate in isolation. They serve as the core component within larger systems that extend their capabilities.

These systems often include:

Retrieval mechanisms (e.g., RAG) to access external knowledge
Tool integration (APIs, databases, code execution)
Memory layers for maintaining context
Prompt engineering or orchestration logic

This creates a layered architecture where the LLM acts as a reasoning and generation engine, while surrounding components provide grounding, structure, and control.

Understanding this distinction is essential: most “AI tools” are not new models, but engineered systems built around LLMs.

8. RLHF: Aligning Models with Human Preferences

Raw language models trained purely on next-token prediction often produce outputs that are inconsistent, unsafe, or misaligned with user intent. RLHF (Reinforcement Learning from Human Feedback) addresses this gap.

The process begins by generating multiple candidate outputs for a given prompt. Human annotators rank these outputs based on quality. A reward model is then trained to approximate these preferences.

Finally, the LLM is optimized using reinforcement learning (commonly Proximal Policy Optimization, PPO) to maximize the reward signal.

This shifts the model’s objective from pure likelihood maximization to preference-aligned behavior.

The result is a model that is more helpful, more coherent, and better aligned with human expectations—though sometimes at the cost of raw diversity or neutrality.

Conclusion

LLMs operate as layered probabilistic systems that transform text into structured representations, model relationships through attention, and generate outputs through iterative decoding.

Their capabilities emerge from the interaction of several components:

Tokenization and embedding
Transformer-based representation learning
Attention-driven context modeling
Probabilistic text generation
Alignment through RLHF

Rather than “understanding” language in a human sense, LLMs approximate it through large-scale statistical learning. Yet at sufficient scale, this approximation becomes powerful enough to support a wide range of real-world applications.