What Makes an AI Agent an Agent?

Most things labeled "AI agent" in 2025 are just a chatbot with a system prompt. What actually makes something an agent is a specific combination of properties: it can take actions in the world (not just generate text), it decides what to do next based on the results of its previous actions, and it keeps going through multiple steps toward a goal without a human manually feeding it each instruction.

If a system reads your message and produces one reply, that's a language model doing inference. If it reads your message, calls a tool, looks at what the tool returned, decides whether it needs to call another tool or is done, and only then replies — that's an agent. The difference isn't marketing, it's architecture: agents run a loop, chatbots run a single pass.

The Four Properties That Actually Matter

Strip away the hype and an AI agent is defined by four things, all of which need to be present at once.

1. It can act, not just talk

An agent has access to tools — functions, APIs, a code interpreter, a browser, a database query — and can actually invoke them. This is what separates "the model told me how to check the weather" from "the model checked the weather." Without tool use, you have a very articulate text generator, not an agent.

2. It decides, it doesn't just follow a script

A workflow that calls step A, then step B, then step C in a fixed order isn't an agent, it's automation — useful, but deterministic. An agent looks at the current state (what the user asked, what the last tool call returned, what's still unresolved) and decides what to do next. Two runs of the same agent on the same input can take different paths if the intermediate results differ.

3. It has memory across steps

An agent needs to track what it already tried and what it learned, at minimum within a single task. Real agents also often keep state across a conversation or session — remembering earlier tool results, earlier user corrections, or earlier failed attempts so it doesn't repeat them. Without this, every step is stateless and the "agent" is really just a stateless function called in a loop by something else (often a human).

4. It runs until a goal is met (or it gives up)

This is the property people underestimate most. A single question-answer exchange isn't agentic behavior, no matter how smart the answer is. An agent keeps working — calling tools, re-evaluating, calling more tools — until it reaches a stopping condition: the goal is satisfied, it hits a retry limit, or it explicitly reports that it's stuck. This is the "agent loop" you'll see described in most agent frameworks: observe, decide, act, repeat.

The Agent Loop, Concretely

Here's what that loop looks like in practice, using tool calls as the mechanism for acting:

async function runAgent(goal, tools) {
  let messages = [{ role: "user", content: goal }];
  let steps = 0;

  while (steps < 10) {
    const response = await callModel(messages, tools);

    if (response.stop_reason === "end_turn") {
      return response.content; // goal reached, agent is done
    }

    if (response.stop_reason === "tool_use") {
      const toolResult = await executeTool(response.tool_call);
      messages.push(response.message);
      messages.push({ role: "tool", content: toolResult });
    }

    steps++;
  }
}

Notice what's happening: the model itself decides whether to stop or keep going (stop_reason), the result of each tool call feeds back into the next decision, and the loop has a bounded number of iterations so it doesn't run forever. That combination — decide, act, observe, repeat, with a stopping condition — is the mechanical definition of an agent. Everything else (personas, prompts, branding) is decoration on top of this loop.

Where the "Agent" Label Gets Misused

A few patterns get called agents that don't meet the bar above:

• Single-turn assistants with a system prompt. No tool use, no loop, no state beyond the conversation. It's a well-prompted chatbot.
• Fixed pipelines. "Step 1 always calls the search API, step 2 always summarizes." No decision-making — it's a script, even if a model writes the summary.
• RAG without action. Retrieving documents and answering from them is powerful, but if the system never decides to act on the world (send an email, write a file, call an external service), it's information retrieval, not agency.

None of these are bad — they're often the right tool for the job, and simpler than a true agent. But calling them agents muddies the term and sets the wrong expectations for what the system can actually do unsupervised.

Building the Loop Without Building the Infrastructure

The hard part of agents usually isn't the decision logic — Claude and similar models already handle tool selection and reasoning well. The hard part is the plumbing: streaming partial responses back to a UI, tracking tool-call state, managing API keys across a team, and getting usage data per user or per agent run.

SubToAPI sits at that layer. It turns your existing Claude access into an HTTPS API with sub_live_... application keys, native support for tool calling so the agent loop above works out of the box, streaming for real-time output, and per-key usage metadata so you can see exactly which agent or which user is burning tokens. It doesn't decide anything for you — that's still the model's job — but it removes the infrastructure work around running the loop in production.

A minimal tool-enabled request looks like this:

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4",
    "max_tokens": 1024,
    "tools": [{
      "name": "get_weather",
      "description": "Get current weather for a location",
      "input_schema": {
        "type": "object",
        "properties": { "location": { "type": "string" } },
        "required": ["location"]
      }
    }],
    "messages": [{ "role": "user", "content": "What is the weather in Lisbon?" }]
  }'

The response tells you whether the model wants to stop or call a tool — the same stop_reason field the loop above checks. See the tool use docs and messages reference for the full request/response shape, or the quickstart to get a key and make your first call.

Questions

Is a chatbot with tool access automatically an agent? Not automatically. It needs to loop — deciding whether to call another tool or stop based on results — not just make one tool call per user message and reply.

Do agents need long-term memory to count as agents? No. Short-term memory within a single task (tracking what it already tried) is enough. Long-term memory across sessions is a useful upgrade, not a requirement.

Can a single API call be "agentic"? A single call can include tool use, but the agentic behavior comes from the loop around it — deciding to call the tool, evaluating the result, and deciding what to do next — not from any one request in isolation.