An AI agent is a system that takes a goal, gathers context, decides what to do, acts through tools, and keeps working until the goal is done or a stop condition fires. That is the whole definition. The interesting part is what each of those words commits you to.

The model is the most visible part of an agent, but it is not the agent. The model reads context and produces tokens. The agent is the thing that puts the model inside a loop, gives it tools, gives it memory, and decides when the loop terminates. The same model, with a different loop, is a different agent.

This piece is the beginner-level entry point. It is meant to give a new operator the vocabulary they need to read the rest of the manual.

Agent, chatbot, automation — what is the difference

Three words get used as if they mean the same thing. They do not.

A chatbot answers one prompt with one response. There is no loop, no tool, no persistence. The model sees the prompt and replies. The conversation ends when the user stops typing.

An agent runs a loop. The loop reads a goal, gathers context, decides what to do, acts through tools, and continues until something terminates the loop. The agent may have memory, may use tools, may delegate to sub-agents. The model is one component inside the loop.

An automation follows a fixed path. The script or the workflow decides what comes next. The model may be called at one step, but the routing is not the model's job.

The boundary between them is fuzzy. A chatbot with a tool call starts to feel like an agent. An automation with a model call starts to feel like an agent. The question is not which word to use; the question is who decides what happens next. If the model decides, it is an agent. If the script decides, it is automation. If the user is still typing, it is a chatbot.

What an agent actually does

A useful agent loop has six stages. The piece on What Is an Agent Loop? walks through each one in detail. The short version:

1. Intake. The agent receives a goal, a task, or a trigger. 2. Context. It gathers what it needs to act well — files, prior notes, the user's preferences. 3. Inference. It decides what to do next, given the goal and the context. 4. Tool execution. It acts on that decision — reads a file, calls an API, runs a script. 5. Persistence. It records what happened in a place that survives the loop. 6. Termination. It checks whether to stop or to run another cycle.

The model is involved in stages three and four. The rest is infrastructure: prompts, tools, memory, and the stop condition.

Why this matters in practice

The reason the definition matters is that most agent failures are not model failures. The model is roughly as capable as it is going to be. What changes between a working agent and a failing agent is the loop around the model.

A weak loop has vague intake, weak context, sloppy tools, no persistence, and unclear termination. The model inside the loop does the best it can with what it sees, and the result is unpredictable.

A strong loop has specific intake, bounded context, well-defined tools, durable persistence, and a written termination condition. The same model inside the strong loop produces predictable behavior.

The whole rest of this manual is about the loop. The model gets better every year. The loop has to be designed once and tends to stay.

What an agent is not

A short list of things that look like agents but are not, or are only partly agents:

  • A search engine. Returns ranked results. Does not act.
  • A copilot. Suggests completions. The user accepts or rejects.
  • A pipeline. Runs in a fixed order. The model is one step.
  • A simulation. Pretends to be an agent but has no real effect on the world.

Each of these can be a part of an agent system. None of them, on their own, is an agent.

The platform question

A common first question is "is the agent OpenClaw, or is it the model, or is it something else?" The answer is that the agent is the whole system, not any one component. OpenClaw is one implementation of the loop. Other agent runtimes implement the same loop in different ways. The model is the component that produces inference. The platform is the component that runs the loop, manages memory, and exposes tools.

When you read pieces on Triadive that say "an agent should do X," they mean the whole system. When you read pieces that say "the model should do X," they mean only the inference stage.

Where to read next

The rest of this manual takes the six-stage loop apart and treats each stage as its own design problem. The reading order that preserves the dependencies:

From there, the manual goes into memory, tools, sessions, and the long-running automation patterns. The vocabulary in this piece is enough to read any of them.

Takeaway

An AI agent is a loop with a model inside it. The loop is the operator's job. The model is the model's job. Most agent work is loop work. The rest of this manual is about how to do that work well.