The first time it unsettled me, I'd asked an AI assistant to "find a good time next week for the three of us and book it." With a normal chatbot I'd have braced for a wall of suggestions to sort through myself. Instead the screen showed a little list of steps ticking by: checking calendars… finding a 45-minute gap Thursday… drafting the invite… sending. I hadn't answered any follow-up questions. I'd handed over a goal and walked away, and the thing had finished the job. What I'd just used wasn't a chatbot. It was an AI agent — a system that takes a goal, decides the steps to reach it, and carries them out using tools, looping until the job is done.
The one-sentence answer
An AI agent is software built around a language model that doesn't just respond to you — it pursues a goal: it plans, takes actions in the real world (search the web, send an email, run code), looks at what happened, and decides the next move on its own.
A language model, the engine inside tools like ChatGPT or Claude, is fundamentally a text predictor (see [How Large Language Models Work](how-large-language-models-work.md)). On its own it can only produce words. An agent is what you get when you wrap that word-engine in a loop and hand it a set of tools — and that wrapping changes everything about what it can do.
The turn: from answering to acting
Here is the whole idea in one line. A chatbot answers the question you asked. An agent works toward the outcome you wanted.
Picture the difference. Ask a chatbot "what's a good time to meet next week?" and it gives you advice — try mornings, check everyone's calendar. You still do the work. Give an agent the same goal and it actually opens the calendars, finds the gap, and sends the invite. Same underlying model. The difference is that the agent was given a loop and a toolbox, and the permission to use both.
How the loop works
Strip away the polish and almost every agent runs the same four-beat cycle, over and over:
- Plan. Break the goal into a next step. "To book the meeting, I first need everyone's availability."
- Act. Use a tool — any external capability the model can call, like a calendar lookup, a web search, or sending a message — to take that step.
- Observe. Read the result. "Thursday at 2pm is the only slot all three share."
- Repeat. Feed that result back in and decide the next step — until the goal is met or it gets stuck.
That last word matters. The loop is what separates an agent from a single clever answer. A chatbot fires once and stops. An agent keeps going — re-planning when a step fails, trying another route, checking its own work — because each pass through the loop hands it fresh information the previous pass didn't have.
What gives it hands: tools
A language model by itself is sealed in a room with no doors; it can only talk. Tools are the doors. A tool is any action you let the model trigger — a calculator, a database query, a flight-booking API, a command to write a file. The model doesn't do these things itself; it decides which to use and when, and the surrounding software actually runs them and reports back.
This is why "agent" and "chatbot" can run on the exact same model and behave like different species. Give the model doors and a reason to walk through them, and it stops being a conversation and starts being a coworker.
A concrete example
You tell an agent: "Research the three coffee subscriptions I bookmarked and tell me which is the best value per cup." Watch the loop turn. It opens the first link (act), reads the price and bag size (observe), realizes it needs cups-per-bag to compare and searches for it (plan, act), does the math, moves to link two, and repeats. Five minutes later you get a short table and a recommendation. You asked one question; it took a dozen small actions to answer it — and you saw none of them unless you looked.
Why it matters
Agents are where AI stops being a thing you consult and becomes a thing you delegate to — and that raises the stakes in both directions. An agent that can send your email can send the wrong email; one that can run code can run bad code. The same loop that makes it useful also means a small early mistake can compound across steps. So the smart posture isn't blind trust or blanket fear. It's the posture you'd take with a fast, eager, slightly green intern: give clear goals, keep the risky actions on a short leash, and check the work.
Try this
Next time you use an AI tool, ask one question: is this thing answering me, or acting for me? If it only returns text, it's a chatbot — the doing is still yours. If it's taking steps in the world on your behalf, you're working with an agent, and you should know exactly which tools it can reach.
And feed it well. An agent is only as good as the goal and the context you hand it — a vague instruction sends it looping in the wrong direction. Keep your own durable notes — the decisions, the constraints, the preferences that matter — and you can hand any agent a tight, specific brief instead of a shrug. Capture those in JustJot.ai, and when you delegate a real task, you'll have the exact context ready to paste — so the agent works toward your outcome, not its best guess at it.
I still remember the small jolt of watching that invite send itself. The lesson stuck: the moment you stop asking and start delegating, your job changes too — from doing the steps to choosing the goal, and deciding how far to trust the thing doing them.