"Agentic AI" gets used loosely enough that it's worth pinning down what actually makes something an agent rather than a chatbot with extra steps. In practice it comes down to three components working in a loop: a planner, a set of tools, and memory.
The planner
The planner is the LLM call that decides what to do next given the current state: the original goal, what's happened so far, and what tools are available. The simplest version is a single prompt that says "here's your goal, here's what you've tried, what's next?" — re-run every iteration.
loop:
observation = get_current_state()
plan = llm.plan(goal, history, observation, available_tools)
if plan.is_done:
return plan.result
result = execute(plan.next_tool_call)
history.append(result)
The failure mode here is loop drift — the model convinces itself it's making progress on a stale sub-goal after five or six turns, especially without a hard step budget or a way to notice it's repeating itself. A step cap and a "have I done this exact tool call before" check catch most of it.
Tools
Tools are the agent's only way to affect or observe the world beyond generating text — an API call, a database query, a file write, a search. The design mistake I see most often is giving an agent too many overlapping tools with fuzzy boundaries ("search_web" and "search_docs" and "lookup_info"), which makes tool selection itself unreliable. Fewer, more clearly-scoped tools with unambiguous names and tight input schemas consistently outperform a large, vague toolset.
Just as important: tools should fail loudly and specifically. A tool that silently returns an empty result on error teaches the agent nothing; a tool that returns {"error": "invoid input: missing 'date' field"} gives the planner something to actually correct on the next turn.
Memory
Memory is what lets an agent act across a session longer than fits in one context window — the running history of what it's tried, what worked, and facts it's gathered. The simplest form is just the accumulated tool-call transcript. More sophisticated setups summarize older turns to control token growth, or persist facts to an external store the agent can query later.
The trap here is treating memory as free. Every extra turn of history is tokens the planner has to re-read and reason over on every subsequent call — a long, noisy history doesn't just cost money, it actively degrades planning quality by burying the signal.
Putting it together
None of these three pieces is hard in isolation. What makes agentic systems hard to get right is that failures compound across the loop: a slightly ambiguous tool schema plus a slightly bloated memory plus a planner with no step budget turns into an agent that spins for twenty turns and burns budget without making progress. Debugging that requires observability into every step of the loop — not just the final answer.
# comments
loading comments...