A chatbot answers a question. An agent tries to achieve a goal: it breaks the goal into steps, uses tools, checks results and keeps going.
The idea has exploded in the last two months. OpenAI announced ChatGPT plugins on 23 March, letting the model call external services. A week later, AutoGPT appeared on GitHub and quickly became one of the fastest-growing repositories on the site, with demos of an AI that researches, writes files and browses the web to pursue open-ended goals. BabyAGI, a compact task-management agent, followed. Stanford researchers published "generative agents": simulated characters that plan their days and remember interactions.
Is this the beginning of autonomous AI, or another hype cycle? Some of both.
How agents work
Most current agents follow a pattern described in the ReAct paper (Yao et al., 2022): interleave reasoning (thinking about what to do) with acting (calling a tool) and observing the result.
flowchart LR G[Goal] --> T["Thought: what should I do next?"] T --> A["Action: call a tool<br/>search, calculator, code, API"] A --> O["Observation: tool result"] O --> T T --> F["Final answer"]
A simplified loop in Python:
TOOLS = {"search": web_search, "calculator": safe_eval, "read_url": fetch_text}
def run_agent(goal, max_steps=8):
history = [f"Goal: {goal}"]
for _ in range(max_steps):
step = llm(
"You can use tools: search(query), calculator(expr), read_url(url).\n"
"Respond with either:\nACTION: tool_name | input\nor\nFINAL: answer\n\n"
+ "\n".join(history)
)
if step.startswith("FINAL:"):
return step.removeprefix("FINAL:").strip()
tool, arg = [s.strip() for s in step.removeprefix("ACTION:").split("|", 1)]
observation = TOOLS[tool](arg) if tool in TOOLS else f"Unknown tool {tool}"
history += [step, f"OBSERVATION: {observation[:2000]}"]
return "Stopped: step limit reached"Frameworks such as LangChain provide this loop, tool definitions, memory and integrations out of the box.
The ingredients
- A capable model. GPT-4's improved reasoning has made agents noticeably more viable than with earlier models.
- Tools: search, code execution, calculators, databases, internal APIs and browsers.
- Memory: short-term (the conversation so far) and sometimes long-term (a vector store of past results).
- Planning: some agents create and update an explicit task list, as BabyAGI does.
What works today
Agents are genuinely useful when the task is narrow and the tools are well defined:
- answering questions that need a few searches or database lookups,
- doing calculations or data analysis with a code interpreter,
- filling in forms or calling APIs from natural-language requests, and
- multi-step research with a human reviewing the output.
What does not work yet
Fully autonomous, open-ended agents like the AutoGPT demos struggle in practice:
- Loops and dead ends. Agents repeat actions, get stuck or wander off-task.
- Compounding errors. A wrong assumption early on derails everything after it.
- Cost. Each step is a model call; long runs with GPT-4 get expensive quickly.
- Evaluation. It is hard to know whether an agent did a good job without checking its work, which erodes the time saved.
- Hallucinated actions. Agents may invent tool names, parameters or "facts" about what they did.
Safety and security
Agents that act raise questions chatbots did not:
- Permissions. An agent with access to email, files or payments can do real damage if it misunderstands or is manipulated.
- Prompt injection. Web pages and documents an agent reads can contain instructions that hijack it.
- Accountability. Who is responsible when an agent takes a wrong action?
Sensible early rules: give agents the minimum tools and permissions they need, require human approval for anything with side effects, cap the number of steps and the spend, and log everything.
Where this is going
The direction seems clear, even if the timeline is not. Models are getting better at reasoning and tool use, providers are adding structured ways to call functions, and frameworks are maturing. The most valuable near-term agents will look less like autonomous digital employees and more like capable assistants that take on defined multi-step tasks under supervision.
The bottom line
AI agents are the natural next step after chatbots: language models that use tools to get things done. The current wave of autonomous agents shows the potential and the limitations in equal measure. Organisations should experiment with narrow, tool-using agents now, with humans firmly in the loop, and build the evaluation and security practices that more autonomous systems will need.
Our agentic AI security team builds practical, supervised agents that take real work off teams, with the guardrails a security company insists on.
