Imagine you hire a very smart intern. You could micromanage them, dictating every single click: "open the browser, go to this site, type this, press enter, now copy that." Or you could just say "book me a flight to Istanbul next Friday, under 300 euros, and email me the confirmation" and walk away. A few minutes later, it's done. That intern who takes the goal, figures out the steps, uses whatever tools they need, checks their own work, and comes back when it's actually finished — that's the difference between a chatbot and an agent.

Wait, isn't a chatbot already "AI"?

Yes, but a chatbot and an agent aren't doing the same job. If you've read my post on deep learning, you know large language models are essentially very good pattern-matchers trained to predict the next word. On their own, a plain chatbot just talks. You ask a question, it answers, conversation over. It has no hands. It can't check your calendar, run code, search the web, or click a "confirm" button. It just generates text and hopes you find it useful.

An agent takes that same language model and gives it a body, sort of. It wraps the model in a loop, gives it access to tools (a web browser, a code interpreter, a calendar API, a file system), and lets it decide, on its own, which tool to use, when to use it, and what to do with the result. Then it repeats that loop until the goal is actually done, not just talked about.

A chatbot answers a question. An agent finishes a task.

So what does an agent actually look like under the hood?

Strip away the buzzwords and most agents run on a surprisingly simple loop:

  • Think: the model looks at the goal and the situation so far, and decides what to do next.
  • Act: it picks a tool, an API call, a search, a piece of code, and actually runs it.
  • Observe: it looks at what came back, an error, a search result, a file, and reads it.
  • Repeat: it loops back to "think" with this new information, until it decides the goal is met.

This loop is often called ReAct (Reason + Act), and it's the backbone of nearly every modern agent, from coding assistants to research bots. Nobody hardcoded the exact sequence of steps beforehand. The model figures out the plan as it goes, and adjusts when something doesn't work, kind of like how, in machine learning, a model corrects itself by learning from its mistakes instead of following a fixed rulebook.

An example, because this stuff gets abstract fast

Say you ask an agent: "Find out why my website's load time got worse this week, and fix it if you can." Here's roughly what happens:

  • It reads your analytics or logs (a tool call) to see what changed.
  • It notices a large image got added recently (observation).
  • It decides that's probably the culprit and opens the file (another tool call).
  • It compresses the image, or rewrites the code to lazy-load it (an action, not just a suggestion).
  • It re-checks the load time to confirm the fix actually worked (self-verification).
  • Only then does it come back and tell you: "Fixed it, here's what I changed."

Notice what didn't happen: you didn't have to say "now open the file," "now edit line 12," "now check if it worked." The agent chained all of that together itself, deciding each step based on what it learned from the previous one.

Why now, though? This didn't exist a few years ago

Three things had to line up:

  • Good enough reasoning: models finally got reliable enough at breaking a fuzzy goal into concrete steps, instead of confidently making things up.
  • Tool use: models learned to output structured "please call this function with these arguments" requests, so software around them could actually execute real actions, not just print text.
  • Longer memory / context: agents need to remember what they already tried three steps ago, so they don't loop forever or repeat mistakes.

None of this replaces deep learning, it's built directly on top of it. The "thinking" step in that loop above is still just a neural network predicting the most sensible next move, the same fundamental mechanism from my deep learning post. Agents are less a new kind of AI, and more a new way of wiring an existing one to the real world.

Where you're already bumping into agents

  • Coding assistants that open files, run your tests, and fix the failures themselves
  • Customer support bots that actually issue the refund instead of just telling you how to
  • Research tools that search, read, cross-check multiple sources, and summarize, without you clicking a single link
  • "Computer use" agents that literally move a mouse and click through a real interface on your behalf

The catch (because there's always one)

Giving a model actual hands is powerful, and also a little scary. An agent that can act can also act on the wrong assumption, delete the wrong file, send the wrong email, or burn through a lot of money and API calls looping on a task it misunderstood. This is exactly why "good agents" spend real engineering effort on guardrails: asking for confirmation before risky actions, checking their own work, and knowing when to stop and ask a human instead of guessing.

The smartest agent isn't the one that never asks questions, it's the one that knows exactly when it should.

The one sentence version

If someone asks you what an AI agent is: "It's a language model wrapped in a loop that can use tools, so instead of just talking about a task, it actually goes and does it, checking its own work along the way."

That's really it. Not a robot, not a separate brain, just the same pattern-matching machine from the deep learning post, given a set of tools and permission to use them until the job's done.

Further reading