Difference Between AI and Agents

Agents are the most talked about topic in my recent AI conversations and it's where the "AI Hype" has shifted. But, what actually is an agent?

You may already know the answer, but in recent conversations it's become clear a lot of people don't have a clear definition of what makes an AI Agentic. So, in this week's issue I'll break down the core differences and definition.

Agent Definition

An AI Agent is an AI that can perform tool calls and reason on the results, deciding what to do next. There are 2 requirements for this:

1. The AI must be specifically trained to be agentic
2. The API call must pass tool call arguments

That's it in its simplest definition. Give the right AI model "hands" or tools and it's now agentic.

What is a "tool?"

Tools are functions the AI can call. For example, say I have a function that checks the weather for a given city. If the model I'm using supports tool calling, I can pass that function as a "tool" in my API request. The tool definition includes a description and parameter requirements, and the agent decides when to call it based on the user's message.

Here's an example of a standard AI API request and an agentic request to get the weather in OpenAI API format:

Standard

{
  "model": "MODEL_NAME",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant"},
    {"role": "user", "content": "hello"}
  ],
  "temperature": 0.3
}

Agentic

{
  "model": "MODEL_NAME",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the weather in Denver?"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather by city",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string"}
          },
          "required": ["city"]
        }
      }
    }
  ],
  "tool_choice": "auto"
}

You can include many tools in the "tools" list. MCP servers, take Gmail for example, are servers that expose endpoints as "tools" for AI Agents. So, if I'm using an agentic model and I've connected my Gmail MCP, I can ask it something like "Check my email and summarize my most recent messages."

The Agent will then look at the "tools" list and decide which tools to call and in which order. It makes the tool call, receives the results, and then decides what to do next. It becomes a series of API requests, which is why Agents eat up usage so much faster.

This one message could turn into 5 API requests with increasing amounts of tokens. Here is a hypothetical example of what it could look like:

User sends Agent Request -> Agent calls "list_emails" tool with limit of 5 -> tool returns 5 most recent emails -> Agent decides it needs more and calls "list_emails" again with start=5 and limit = 10 -> tool returns 10 new unread emails -> Agent responds to user with a summary*

Even in this simple use case, you can see how an Agent uses significantly more tokens. Coding agents can have many tools and have massive chains navigating users codebases. But, it's also obvious that Agents are far more capable than just traditional API requests.

The analogy that I like most is that you're giving the AI "arms," making it an agent. It can not only respond or provide information, but can actually perform actions.

Self-Hosted Agents

There have been some Open Source AI Models released recently that are specifically trained to be AI Agents.

1. Gemma 4 — Trained to be a powerful generalist agent capable of handling a variety of different use cases
2. Qwen3.6 — Capable models specifically tailored for Agentic Coding.

Both of these model families can be run on less than 64GB of memory which is insane to me. They both use novel architectures and have extensive training, outperforming models 15x their size.

By running agents locally you can now run autonomous agents and powerful coding assistants without paying expensive cloud bills or burning through your subscription's usage limits.

This is why self-hosting is the future of AI. Just like with the personal computer, AI models are getting smaller, more efficient, and will be run at home for a one-time hardware purchase instead of expensive cloud subscriptions.

Author: Jackson Oaks