AI Agents

The plain-language idea

A plain chat completion has a fixed shape: you send a request, the model generates a response, the interaction ends. Giving the model function calling (the ability to request that a specific tool be invoked, with specific arguments) doesn't change that shape by itself — a single call that decides to invoke one tool and return a result is still just one request-response cycle, only with an extra step inside it.

An agent is what you get when you take that same tool-calling model and put it in a loop: given a goal, the model plans a next step, acts (calls a tool), observes the result, and then decides for itself whether the goal is met or another step is needed — repeating until it's done or it gives up. The defining thing isn't the tools. It's the loop, and specifically who controls it: the model decides how many steps to take and in what order, not a developer hardcoding "call tool A, then tool B, then respond."

That's also the honest boundary to draw in an interview: "an LLM with function calling" and "an agent" are not automatically the same thing. A single tool call inside one request-response cycle is function calling. Only when the model is allowed to keep looping — re-planning based on what it just observed — does it become agentic.

See it in a real thing: a goal that takes more than one step to satisfy

// Rough sketch of an agent loop — NOT this app's actual implementation,
// which doesn't run agents; this is the general shape the pattern takes.
async function runAgent(goal: string, tools: Tool[]) {
  const history: Message[] = [{ role: "user", content: goal }];

  while (true) {
    const step = await model.generate({ messages: history, tools });

    if (step.type === "final_answer") {
      return step.content; // model decided the goal is met — loop ends here
    }

    // step.type === "tool_call": act, then observe the result
    const result = await callTool(step.toolName, step.args);
    history.push({ role: "assistant", content: step.raw });
    history.push({ role: "tool", content: JSON.stringify(result) });
    // loop back to plan again, now with the tool's result in context
  }
}

A goal comes in. The model plans its next step toward it.

BackNext

Nothing here forces a fixed number of steps. A simple goal might resolve in one tool call; a harder one might take five, with the model changing its plan after seeing what the third tool call actually returned. That open-ended, model-driven step count is exactly what a single fixed function-calling request-response can't do.

What people usually miss

Watch out

• Function calling alone is not an agent. A single request where the model calls one tool and returns a result is one request-response cycle with an extra step in it — the loop is the differentiator, not the presence of tools.
• The model controls the step count, not the developer. That's what makes agent behavior harder to test and reason about than a fixed pipeline: the same goal can legitimately take a different number of steps on different runs.
• "Observe" is a real step, not a formality. The result of a tool call gets fed back into the model's context before the next planning step — a broken or misleading tool result can send the whole loop down the wrong path, since the model is planning off what it just observed, not off the original goal alone.
• More autonomy means more failure surface. An agent that plans its own steps can also plan a bad one — call the wrong tool, misread a result, or loop unnecessarily — which is why unbounded agent loops without a stopping condition are a real production risk, not a hypothetical one.

Why this matters in interviews

"What actually makes something an agent, versus just an LLM that can call functions?" is a common way this gets tested, and naming the loop — plan, act, observe, decide — plus who controls it (the model, not a fixed script) is the answer that shows real understanding rather than buzzword familiarity.