JOVANA
Explore Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

From Chatbot to Agent: When a Model Starts to Act

A plain chat model answers; an agent does. Meet the observe–think–act loop that turns a language model into something that pursues a goal.

The gap between answering and doing

Ask a plain chatbot to "book me the cheapest flight to Tokyo next Friday" and the best it can do is describe how you might book one. It has no way to open a website, compare prices, or press a button. It produces text and stops. An LLM agent closes that gap: it is a language model placed inside a loop where it can take actions in the world — call a search API, run code, click a link — observe what happens, and decide what to do next.

The shift is subtle but huge. A chat model maps text in → text out. An agent maps goal in → a sequence of actions that change the world until the goal is met. The same underlying model now drives a process. We call the model's ability to carry a multi-step job to completion on its own autonomous task execution.

A plain chat model works like this: text in, text out — one token at a time, with no way to act on the world.

Autoregressive generation diagram: a prompt feeds a model that emits one token at a time, each appended and fed back in.

The agent loop: observe, think, act

Every agent, no matter how fancy the framework, runs the same heartbeat. The model looks at the current situation, reasons about what to do, emits an action, the environment runs that action and returns a result, and the loop repeats. This back-and-forth is the agent's feedback loop — the model is never flying blind, because each action returns an observation that grounds the next decision.

  1. Observe — read the goal plus everything gathered so far (the latest tool output, the page just loaded, the error just thrown).
  2. Think — reason about the situation and choose the next move; often the model writes its reasoning out loud before committing.
  3. Act — emit a concrete action: call a tool, run a query, or declare the task finished and hand back an answer.
  4. Loop — the environment returns a fresh observation, and the cycle starts again until the goal is reached or a stop condition fires.
The agent's heartbeat: observe the situation, think about what to do, act — then loop on the fresh result.

A cyclic diagram of an LLM agent's reason, act, and observe stages feeding back into one another.

Three ingredients an agent needs

A capable agent stands on three legs. Tools give it hands — the ability to do something other than emit text; we call this tool use, and choosing the right tool for the moment is tool selection. Planning gives it foresight — breaking a vague goal into ordered sub-steps, which is agent planning. Memory gives it continuity — holding on to facts, results, and earlier decisions across many loop turns, which is agent memory.

Take away tools and the agent can only think out loud. Take away planning and it lurches from action to action with no strategy. Take away memory and it forgets what it learned two steps ago and repeats itself. The next four guides build each leg up in turn; this guide just plants the picture in your head.

A first concrete trace

Here is what a single short task actually looks like as a loop trace. Notice that the model never guesses the weather — it acts to find out, then reads the result back before answering.

Goal: "Should I bring an umbrella to my 3pm meeting in Taipei?"

Think:  I don't know today's Taipei forecast. I should look it up.
Act:    get_weather(city="Taipei", when="today 15:00")
Observe: { temp_c: 27, rain_chance: 0.8, condition: "showers" }

Think:  80% chance of showers at 3pm. That's high. I can answer now.
Act:    finish("Yes — bring an umbrella; ~80% chance of showers at 3pm.")
One pass through the observe–think–act loop for a tiny task.