The model is an engine. An agent is a vehicle.

A large language model predicts plausible next tokens given the text so far. That is the whole magic trick, and it is enough to write fluent paragraphs. It is not enough to file a ticket, query a ledger, or know whether last turn’s tool call actually succeeded.

AI Right Now Part 4 is the public story of fluency: calm sentences are not proof. This part is the architectural one. Inside an agent, the LLM is the component that proposes — the next thought, the next plan fragment, the next tool request. Something else has to run the world and write the result back.

What the engine actually does

You assemble a context window: system instructions, the user goal, recent turns, tool results, maybe retrieved snippets. The model continues that context. If your runtime advertised tools, the continuation might be ordinary prose or a structured “please call this function” blob. Either way, the model did not open a socket. It emitted tokens.

That distinction matters when a demo says “the AI queried the database.” No. The model produced a request that looked like a query. Your code — or a vendor runtime — executed it. Part 5 is that contract. Part 4 is the catalog of hands.

Until those layers exist, you have a chatbot. Useful. Not an agent.

Next token, transformer-era engine

“Predict the next token” is not a metaphor. Given tokens t₁ … tₙ, the model assigns probabilities to tₙ₊₁ and you sample or take the top. Do that again. Fluency is that loop at scale.

Most of the engines in production agents are transformer-era designs in the sense of Vaswani et al. (2017) — attention over a context window instead of a single left-to-right hidden state that forgets the start of the prompt. You do not need the paper to call an API. You need it to stop thinking the model “has a mind” sitting beside the window. It has weights and a window. What does not fit in the window is gone unless memory or RAG writes it back in.

Wikipedia’s LLM page is a fair glossary. The architectural claim is narrower: next-token generation over a finite context is the engine. The agent is everything you wrap around that engine.

What the engine cannot do alone

  • See the live world. Weights do not include this morning’s order table.
  • Remember past the window. Unless memory writes something down, the next call starts poorer.
  • Guarantee a plan. It can outline steps. Planning is using observations to change those steps.
  • Undo a side effect. Tokens do not roll back a payment API.

From Models to Agents already walked chat → reasoning → tools as eras. Keep that timeline. Here the LLM stays in the diagram even after the eras move on. Agents did not replace language models. They wrapped them.

Example

Goal: “Find last week’s failed payments and draft tickets.”

The model might output a beautiful three-step plan and a JSON-shaped query. If nobody runs the query, you have an essay. If somebody runs it and pastes the rows back into the next prompt, the model can draft tickets from data instead of from vibes. Same engine. Different machine.

Conclusion

When someone says “we deployed an agent,” ask which model — then ask what sits around it. The interesting failures are rarely “the LLM forgot English.” They are empty context, unrun tools, and nobody scoring the path.

Takeaway: The LLM proposes language and tool requests. It does not query, remember, or act unless the rest of the stack does.

Sources

Series start: Introduction
Part 2: Memory