Agents: the layer that turns generation into action
An agent is a system that can perceive, decide, and act — often using tools, APIs, and other capabilities. This page is the base layer of the agents stack: what an agent is, how it differs from a plain LLM, and why knowledge is what makes its actions dependable.
What is an agent in AI?
An agent is a system that can perceive its environment, make decisions, and act — often using tools, APIs, or other capabilities — to achieve a goal. In modern AI, this usually means an LLM-based system that can plan, call functions, read state, and continue across multiple steps, rather than only generating a single response.
Agents vs plain LLMs
A plain LLM generates text. An agent acts.
The difference is not just a bigger prompt. An agent has a loop: it receives input, decides what to do, optionally uses tools or calls external systems, observes the result, and continues. That loop is what turns a model from something that answers into something that does.
This distinction matters for the knowledge layer because the agent's actions depend on knowledge at every step: what is the current state, what does the tool expect, what is the right procedure, what is still true, and what is the agent allowed to do. A plain LLM's failure is usually a wrong answer. An agent's failure is often a wrong action.
Related pages: LLMs are usually the reasoning core; MCP is one way to give agents tool access; Tool use is the action layer; Computer use is the interface layer when the agent acts on a computer.
Why knowledge matters for agents
Agents make knowledge failures more expensive, not less.
An agent that plans a workflow is using knowledge about the workflow's rules. An agent that calls an API is using knowledge about the API's contract. An agent that answers from internal data is using knowledge about what is authoritative and current. An agent that explains itself is using knowledge about what it did and why.
When an agent has weak knowledge — stale procedures, missing context, the wrong tool contract, unclear permissions — it does not simply give a bad answer. It can take a bad action, repeatedly and at speed. That is why the knowledge layer is first-class for agents: the cost of being wrong is higher, and the system is acting on whatever knowledge it has, good or bad.
The agents stack, at a glance
An agentic system is usually more than "an LLM." The stack includes:
- Reasoning core. Usually an LLM, sometimes more than one. This is where the model reasons about what to do.
- Plan / loop. The structure that lets the agent decide, act, observe, and continue.
- Tools and interfaces. APIs, functions, and possibly computer-level actions. MCP is one standard way to expose tools; computer use is one way to act on a UI.
- Knowledge layer. The facts, procedures, state, permissions, and representations the agent acts on.
- Guardrails and constraints. What the agent is allowed to do, what it should not do, and what it should do when it is not sure.
Knowledge is the cross-cutting layer in that stack. It is what the reasoning core reasons over, what the tools expect, what the plan depends on, and what the guardrails are protecting.
Where to go next
- LLMs — the reasoning core behind most agents.
- MCP — a standard way to give agents tool access.
- Tool use — the action layer.
- Computer use — acting on a computer interface.
- Knowledge Lifecycle — the topic layer that makes agents dependable.
- Contact
Frequently asked questions
An agent is a system that can perceive its environment, make decisions, and act — often using tools, APIs, or other capabilities — to achieve a goal. In modern AI, this usually means an LLM-based system that can plan, call functions, read state, and continue across multiple steps, rather than only generating a single response.
A plain LLM generates text from a prompt. An agent can take actions: it can plan, call tools, read state, write back, and often continue across multiple steps. The agent is the layer that turns generation into action, and knowledge is what it acts on.
Because agents act on what they know. If the agent's knowledge is stale, incomplete, poorly represented, or out of scope, the agent will make confident mistakes. The knowledge layer is what makes the agent's actions dependable rather than just fluent.
Sources and further reading
- Retrieval-Augmented Generation for Large Language Models: A Survey — arxiv.org/abs/2312.10997
- Cost-Aware Query Routing in RAG: Empirical Analysis of Retrieval Depth Tradeoffs — arxiv.org/abs/2606.02581