The short answer
A large language model (LLM) is a trained model that takes text as input and produces text as output, drawing on linguistic and reasoning patterns learned during training. An agent is a software system that uses a model like this as one of its internal components, but adds a goal it works toward, context and tools it can call, memory to retain what happened, and a control loop that decides what to do next across multiple steps, instead of just returning one response to one input.
What an LLM is
Functionally, a language model is a function: it takes text (or images and other inputs, for multimodal models) and produces a text response. That response is the result of statistical reasoning over learned patterns, not the actual execution of any action beyond generating text. On its own, a model has no memory between requests, doesn't call tools, and doesn't decide when to stop working — all of that is added around it by whatever application uses it.
What an agent is
An agent builds an additional layer around a model (or several) that turns text generation into goal-directed behaviour. It receives a task, retains its context, may call external tools to fetch information or take actions, and repeats this across multiple steps until it reaches a result or stops according to a defined rule. Within this system, the model handles reasoning at each step — interpreting the current state and proposing the next move — while the rest of the system gives that reasoning practical meaning and translates it into actual actions.
Components: tools, memory, actions, control loop
- Tools: external functions the agent can call, such as search, querying a database, or sending a request to another system.
- Memory: what the agent retains of conversation or task context across steps, whether short-term within a session or longer-term across sessions.
- Actions: the concrete steps the agent executes as a result of reasoning — calling a tool, updating memory, or delivering a final answer.
- Control loop / orchestration: the logic that decides, after each step, what happens next: another step, a request for clarification, or ending the task.
Not every step in this loop is necessarily a model call. Part of the orchestration, output validation, and routing between tools can be plain deterministic code that doesn't invoke a model at all, while the model is called specifically at reasoning points that need natural-language understanding or a decision that can't be encoded as a fixed rule.
Autonomy and interacting with the environment
What distinguishes an agent in practice is its ability to interact with an external environment across multiple steps without the user having to script every step manually. The degree of autonomy varies: some agents propose an action and wait for human approval before executing it, while others are granted permission to execute certain actions directly within a predefined scope. In both cases, the essential difference from a standalone model is a loop connecting reasoning to external action, not just a text response.
Important clarifications
It's common to assume every agent depends on one specific model architecture or a single vendor, but that isn't accurate. An agent can use more than one model for different tasks within the same flow — a general reasoning model and a specialised model for a sub-task, for example — or swap its underlying model without changing the rest of its architecture. Likewise, having a strong language model doesn't automatically mean you have an agent: an agent needs the additional layer of goals, tools, memory, and a control loop for reasoning to become actual goal-directed behaviour.
Comparison table
| Criterion | LLM | AI agent |
|---|---|---|
| Input/output | Text (or other modalities) in, text out, per single request | A task or goal, potentially producing several actions and outputs across multiple steps |
| State | No inherent memory between requests unless context is passed manually | Retains context memory across task steps, sometimes across multiple sessions |
| Tool access | Doesn't call external tools on its own | Calling external tools is a core part of its operation |
| Side effects on external systems | No direct effect beyond generating text | May execute real actions that change state in external systems |
| Evaluation | Quality of text generation and reasoning on a single input | Task completion rate, correctness of actions taken, and end-to-end outcome integrity across steps |
| Common failure modes | Inaccurate answers or language hallucination in a single response | May also include calling the wrong tool, a stuck loop with no progress, or an unintended external action |
Related comparisons
This article specifically covers the difference between an agent and a language model as a reasoning component. If your question is about the difference between an agent and a traditional chatbot, or between an agent and classic automation without reasoning, or between an agent and an end-user-facing AI assistant, those are different comparisons covered in "AI agent vs chatbot", "AI agent vs automation", and "AI agent vs AI assistant" respectively.