Today's AI systems and their limits

The AI systems people use today, chat assistants, coding tools, image generators, translation apps, voice assistants, are built on the ideas of Lesson 3, scaled up enormously. A modern language model is a neural network with billions or trillions of parameters, trained by gradient descent on a large fraction of the text humanity has written, then refined with human feedback. The result can be astonishingly capable and, in places, surprisingly unreliable.

This chapter explains how large language models work, how they are trained and turned into assistants and agents, what other kinds of AI systems are in wide use, how much computation they take, and where they fail. Using AI well, and building it responsibly, depends on understanding both sides.

Large language models

Tokens

Language models do not read letters or whole words. They read tokens: chunks of text from a fixed vocabulary of tens of thousands to a few hundred thousand pieces. Common words are single tokens; rarer words are split into pieces ("electro", "cardi", "ogram"). In English, a token averages roughly three-quarters of a word, so 1000 tokens is about 750 words. Prices, speed limits and memory limits for language models are all measured in tokens.

Predicting the next token

At its core, a language model does one thing: given a sequence of tokens, it outputs a probability for every possible next token. To generate text it picks a token, appends it, and repeats. The network computes raw scores called logits, and a function called softmax turns them into probabilities:

Here \(z_i\) is the score for token \(i\) and \(\tau\) is the temperature, a setting that controls randomness. Low temperature makes the most likely token dominate; high temperature spreads probability more evenly, giving more varied (and more error-prone) text.

Predicting the next token sounds trivial, but doing it well across all kinds of text requires a model to capture grammar, facts, styles, arithmetic, programming languages and patterns of reasoning, because all of these help predict what comes next. That is the bet behind language models, and it has paid off far beyond what most researchers expected.

The transformer inside

Nearly all language models use the transformer architecture (Lesson 2). Each token is turned into a vector of numbers (an embedding). The model then passes these vectors through dozens of layers. In each layer, an attention mechanism lets every token gather information from the earlier tokens most relevant to it (in "the pump that the technician replaced was noisy", "was noisy" needs to attend to "pump", not "technician"), and a feed-forward network processes each token further. The final layer produces the logits for the next token. The amount of text a model can attend to at once is its context window, now commonly hundreds of thousands of tokens for leading models.

From raw model to assistant

A model trained only to predict internet text will continue a question with more questions, or produce whatever is statistically likely, including falsehoods and toxic text. Turning it into a helpful assistant takes several stages.

• Pretraining: self-supervised next-token prediction on trillions of tokens of text (and often images, audio and code). This is where nearly all the computation goes and where the model acquires its knowledge and skills.
• Supervised fine-tuning: further training on curated examples of good responses to instructions, often written by people.
• Learning from feedback: people (or other models guided by written principles) compare pairs of responses, and the model is trained with reinforcement learning to produce responses that are judged better: more helpful, more honest, less harmful. This is commonly called reinforcement learning from human feedback (RLHF).
• Reasoning training: many recent models are also trained with reinforcement learning on problems with checkable answers, such as mathematics and code, so they learn to work through problems step by step before answering.

Deployed assistants are usually connected to tools. Retrieval-augmented generation (RAG) searches a document collection or the web and gives the model the relevant passages, so answers can be grounded in sources rather than memory. Tool use lets the model run code, call a calculator, query a database or operate software. An AI agent is a model that plans and carries out multi-step tasks with such tools, observing the results and deciding what to do next: the agent loop of Lesson 1, with a language model as the decision-maker.

How much computation?

A useful rule of thumb estimates training compute for a transformer: about 6 floating-point operations (FLOP) per parameter per training token.

where \(N\) is the number of parameters and \(D\) the number of training tokens. Generating each token afterwards costs about \(2N\) FLOP.

Inference (using a trained model) also adds up. Serving millions of users, each generating thousands of tokens a day, keeps large data centers busy around the clock, and reasoning models that "think" at length before answering generate many more tokens per question. This is the demand driving the data center boom described in DCE-200.

Beyond language models

Language models attract the headlines, but many other AI systems are in daily use:

• Image, audio and video generation, mostly with diffusion models, which learn to turn random noise step by step into a picture or sound that matches a description.
• Speech recognition and synthesis, now accurate enough for live captioning and natural-sounding voices.
• Computer vision for medical imaging, manufacturing inspection, agriculture, security and self-driving vehicles; robotaxis now carry paying passengers without a safety driver in several cities.
• Recommendation systems that decide what billions of people see in feeds, stores and streaming services; probably the most economically important AI of the past decade.
• Scientific AI such as AlphaFold, which has predicted structures for hundreds of millions of proteins, and models for weather forecasting, materials and drug discovery.
• Forecasting and optimization in industry: predicting electricity demand, scheduling maintenance, routing deliveries, controlling data center cooling.

Where today's systems fail

Every engineer using AI must know its failure modes. These are not rare glitches; they follow from how the systems are built.

Hallucination

Language models generate plausible text, not verified facts. When a model lacks knowledge, it may still produce a confident, fluent, specific answer that is wrong: a fake citation, an invented code clause, a wrong figure. These are called hallucinations (or confabulations). Retrieval with sources, tool use and training for honesty reduce them but do not eliminate them.

Errors compound in long tasks

Agents perform many steps in a row, and a mistake at any step can derail the task.

Other limits

• Brittleness and distribution shift: models can fail when inputs differ from their training data: a vision system trained in sunny weather meeting snow, or a model asked about events after its training cutoff.
• Adversarial inputs: small, deliberately crafted changes, such as stickers on a stop sign or hidden instructions in a web page (prompt injection), can make a model behave badly.
• Sensitivity to phrasing: rewording a question can change the answer.
• Bias: models learn patterns, including unfair ones, from their training data (Lesson 5).
• Opacity: it is hard to explain why a large network produced a particular output; interpretability research is still young (AI-430).
• Cost and energy: training and serving large models takes enormous computation, electricity and, in some data centers, water.

Using AI well

For engineers, a few habits follow from all of this:

• Treat AI output as a draft from a capable but unreliable assistant. Verify facts, figures and code before relying on them, especially in safety-critical work.
• Ground answers in sources: ask for citations and check them, or use retrieval over trusted documents.
• Use tools for exact work: calculators, solvers and tests, not the model's mental arithmetic.
• Measure performance on your own task with your own test cases, rather than trusting general benchmarks.
• Keep humans responsible for decisions with serious consequences. A licensed engineer who signs a drawing is responsible for it, whatever tools were used to produce it.
• Protect confidential data: know where the text you send to an AI service goes and how it is stored.