← All writing
AI

Building AI Agents That Actually Work

An agent is just an LLM in a loop with tools and a goal. The hard part is not the loop — it is keeping it bounded, observable, and recoverable when the model is wrong.

"Agent" has become the most over-promised word in AI. Strip away the hype and the idea is simple: give a language model a goal, a set of tools, and a loop, and let it decide what to do next until the job is done. The mechanism is trivial. Making it reliable enough to ship is the entire challenge — and it is an engineering problem, not a prompting trick.

Observe→ Reason→ Act (tool)→ Result↺ until goal met
The agent loop — observe state, reason about the next step, call a tool, feed the result back, and repeat until the goal is reached or a limit is hit.

Tools are the agent's real capabilities

A model without tools can only talk. Tools — search, a database query, an API call, a calculator — are what let it act on the world. Define each one with a precise schema and a tight description, because the model chooses tools entirely from those descriptions. Vague tool definitions are the most common reason agents flail.

An agent is only as good as its worst-described tool. Treat tool specs like a public API.

Bound the loop or it will run forever

The defining failure mode of agents is the runaway loop: the model retries the same broken action, talks to itself, or burns your budget chasing an impossible goal. Every production agent needs hard limits — a maximum number of steps, a token ceiling, timeouts, and a clear definition of "done" it can recognise.

let steps = 0;
while (!goalMet(state) && steps++ < MAX_STEPS) {
  const next = await agent.decide(state);   // pick a tool + args
  const result = await tools.run(next);     // execute, with timeout
  state = update(state, result);            // observe
}
if (steps >= MAX_STEPS) escalateToHuman(state);

Make every step observable

When an agent does something surprising, you must be able to replay exactly what it saw and chose. Log every observation, decision, tool call, and result as a trace. Without that, debugging an agent is guesswork; with it, each failure becomes a fixable case.

Keep humans on the dangerous edges

Let the agent run freely on cheap, reversible actions — reading, drafting, searching. For anything irreversible or costly, the agent should propose and a human should approve. The art of agent design is drawing that line precisely, so autonomy buys speed without betting the business on a confident mistake.

  • Reversible & cheap: let the agent act autonomously.
  • Irreversible or costly: require explicit human approval.
  • Uncertain: have the agent ask rather than guess.

The agents that work in production are not the most autonomous — they are the most contained. Bound the loop, describe the tools well, trace everything, and keep a human on the sharp edges, and an LLM in a loop becomes genuinely useful.

Keep reading