An AI agent is a system built around a language model that can take actions — not just generate text, but plan, use tools, and interact with external systems to accomplish a goal across multiple steps, rather than producing a single one-shot response.
What Distinguishes an Agent from a Plain LLM Call
| Plain LLM Call | Agent |
|---|---|
| One prompt in, one response out | Can take multiple steps, observing results and deciding what to do next |
| Limited to what it can generate from its own knowledge | Can call external tools (search, calculators, APIs, code execution) to gather information or take real actions |
| No persistent goal-tracking across steps | Maintains and works toward a defined goal, potentially across many steps and tool calls |
The Core Agent Loop
# A simplified conceptual agent loop
def run_agent(goal, tools, max_steps=10):
history = [f"Goal: {goal}"]
for step in range(max_steps):
# 1. The LLM decides: respond directly, or call a tool?
decision = llm.generate(prompt=build_prompt(history, tools))
if decision.is_final_answer:
return decision.answer
# 2. Execute the chosen tool call
tool_result = tools[decision.tool_name](**decision.tool_args)
# 3. Observe the result and continue the loop
history.append(f"Called {decision.tool_name}, got: {tool_result}")
return "Max steps reached without a final answer"This "reason, act, observe" cycle — often called the ReAct pattern in the literature — repeats until the agent determines it has enough information to produce a final answer, or reaches a step limit.
Why Agents Are Powerful, and Why They're Risky
Agents extend a language model's capability well beyond its fixed training knowledge — they can look up current information, perform precise calculations a language model alone is unreliable at, and take real actions in external systems. But this power is exactly what makes agents riskier than a plain text-generation call: an agent that can execute code, make purchases, or send emails can cause real, potentially harmful consequences if it misinterprets its goal or a tool's output, which is why sandboxing, human approval checkpoints, and careful tool-permission scoping matter significantly more for agents than for simple text generation.
Common Agent Failure Modes
- Looping — repeatedly attempting the same failing action without recognizing it isn't working.
- Goal drift — gradually losing track of the original objective across many steps.
- Tool misuse — calling a tool with incorrect or nonsensical arguments, or misinterpreting a tool's output.
- Unsafe actions — taking a consequential, hard-to-reverse action (e.g. deleting data, sending a message) without appropriate safeguards or confirmation.
Common Mistakes
- Granting an agent broad, unrestricted tool access without appropriate scoping or approval checkpoints for consequential actions — this significantly amplifies the potential impact of any agent mistake or misinterpretation.
- Not setting a maximum step limit — an agent stuck in an unproductive loop can otherwise consume compute indefinitely without ever reaching a useful conclusion.
Interview Relevance
Q: "Why do AI agents introduce risks that a simple, single-turn LLM text generation call doesn't have?" A plain LLM call only produces text — any harm from a mistake is limited to the text itself being wrong or unhelpful. An agent, by contrast, can take real actions through tool calls — executing code, making API calls, modifying data, sending communications — meaning a mistake (misinterpreting the goal, misusing a tool, looping unproductively) can cause real, sometimes hard-to-reverse consequences in external systems. This is why agents need additional safeguards — sandboxed execution environments, human approval checkpoints for consequential actions, and carefully scoped tool permissions — that a plain text-generation system doesn't require to the same degree.
Practice Question
Why is setting a maximum step limit an important safeguard for an AI agent, even when it appears to be "making progress" toward its goal?
