The word "agent" has been stretched so thin it's nearly useless. Every product calls itself agentic now. Assistants, pipelines, chatbots with a search button — all agents, according to their marketing. Let's actually be specific about what the word means when it's used carefully.
A chatbot responds. You ask, it answers. The interaction is complete.
An acts. It takes your goal, figures out the steps, runs them, looks at what came back, adjusts, and keeps going until the goal is reached — or until it decides it can't.
That last part matters too.
The key distinction isn't capability. It's the loop.
The loop is the thing
An agent's defining trait is that it runs in a feedback loop with the world. It doesn't just generate output — it observes state, picks an action, takes it, observes the new state, and repeats. The simplest version of this pattern is sometimes called [·], shorthand for Reason and Act.
Observe what the current state is. What tools are available? What's already happened? What does the environment look like?
Reason about what to do next. Not necessarily deep reasoning — sometimes it's just: "I need to search the web before I can answer this."
Act by calling a tool, writing a file, sending a request, generating text.
Observe the result and decide what's next.
def run_agent(goal: str) -> str:
messages = [{"role": "user", "content": goal}]
while True:
response = llm.complete(messages, tools=AVAILABLE_TOOLS)
# If the model stopped calling tools, it's done
if not response.tool_calls:
return response.content
# Execute each tool call, feed results back into context
for call in response.tool_calls:
result = execute_tool(call.name, call.arguments)
messages.append({"role": "tool", "content": str(result)})
messages.append(response)
The model is often fine. The scaffolding around it is what cracks.
◉ INTERACTIVE
Pick a goal to watch an agent work:
What separates agents from assistants
You can give a chatbot tools and it'll use them. That's not quite the same as an agent.
What makes something agentic is multi-step autonomy — pursuing a goal across multiple actions without a human stepping in at each one. An assistant with will search the web if you ask it to search. An agent will search, read the results, notice they're useless, search again with a refined query, extract the relevant sections, cross-reference them, then write its response.
The agent decides what to do at each step. You set the goal once.
This is why planning matters so much in agent design. A good agent doesn't just execute the first thing it thinks of — it considers the goal, breaks it into subproblems, and sequences actions in a sensible order. Whether the planning is explicit (the agent writes out a plan first) or implicit (the model just reasons through steps naturally) varies a lot by approach.
The hard parts nobody talks about first
Building an agent is easy. Building one that works reliably is much harder, and almost none of the difficulty lives where you'd expect.
Tool reliability is the ceiling. An agent is only as good as its tools. If a web search returns garbage, or a file reader silently fails, the model is reasoning on bad premises. Agents amplify whatever quality your tools have — for better or worse.[·]
Context accumulates. Each tool call adds more to the conversation. Long agent runs hit token limits, or the model loses track of the original goal under the weight of intermediate results. Good agent design thinks about what to trim, summarize, or move out of .
Error handling needs explicit design. When a human gets a confusing result, they reconsider. An agent will keep going unless you've built in logic to recognize that something went wrong and try a different approach. Production agents invest heavily in retry logic, error pattern detection, and graceful exits.
Major providers now ship official tool-use APIs[·][·] that handle a lot of the plumbing for you — schema parsing, message routing, error envelopes. Use them. Hand-rolling this stuff is a rite of passage you'll regret.
The most useful mental model: an agent is a model running inside a while loop, with tools as its hands and observations as its eyes. What makes an agent good isn't magic in the model — it's the quality of the loop, the tools, and the scaffolding that keeps the whole thing from going sideways.
The loop is ordinary. Done well, what it can do is not.