AI Agent vs LLM vs AI Assistant

What is the difference between an AI agent, an LLM and an AI assistant?

An AI agent, an LLM and an AI assistant are three layers of one stack, and the way to tell them apart is to ask what each one needs from a server. An LLM (large language model) is a file of weights that needs RAM and compute. An assistant is that model wrapped in a chat surface, with an account and saved history, almost always on someone else's hardware. An agent is an assistant that also has tools and a loop, and it holds credentials, which is what forces it onto a machine that stays on.

Most writing on this question stops at the definitions. The definitions only matter because each layer bills you differently. One costs RAM. The next costs a public URL and TLS (transport layer security). The last costs credentials, and a credential an agent has used is a credential you now have to rotate.

An LLM is weights, and weights need RAM

An LLM is a file of numbers. You download it, a runtime loads it into memory, and it answers one request at a time. The contract is narrow: text goes in, text comes out. The model has no memory between calls, no clock, no network access and no way to open a file. Everything an LLM appears to remember was pasted into its context by the program calling it.

The number that decides your VPS plan is the size of that file, because the whole thing sits in memory while the model runs. At the 4-bit quantisation that Ollama ships by default, count on roughly 0.6 GB per billion parameters, then add a gigabyte or two for the context window and the runtime itself.

[
  {
    "label": "qwen3:4b",
    "download_gb": 2.5,
    "ram_gb_needed": 6
  },
  {
    "label": "qwen3:8b",
    "download_gb": 5.2,
    "ram_gb_needed": 8
  },
  {
    "label": "qwen3:14b",
    "download_gb": 9.3,
    "ram_gb_needed": 12
  },
  {
    "label": "qwen3:32b",
    "download_gb": 20.0,
    "ram_gb_needed": 24
  }
]

The qwen3:8b build is 5.2 GB on disk and wants about 8 GB of RAM to run without swapping. A 4 GB VPS will not load qwen3:14b, which is 9.3 GB before you type a single word into it. The largest row here, qwen3:32b, needs about 24 GB, which on most price lists is a different plan and a different monthly bill.

Fitting in memory is one question. Speed is another. On a CPU-only VPS the bottleneck is memory bandwidth rather than clock speed, so a model that fits can still answer at a few tokens per second. That is fine for a job that runs overnight and unpleasant for chat. A GPU moves that figure by roughly an order of magnitude, and it moves your bill too, so decide with a measurement: benchmark the VPS with the workload you plan to run and read when a GPU VPS earns its price. To get weights running at all, start with Ollama on your own VPS.

An assistant is an LLM plus a chat surface

An assistant is the product layer around a model. ChatGPT and Claude are assistants: a model, a chat window, an account, saved conversations, a rate limit. Almost none of that runs on hardware you control, which is why a hosted assistant costs a subscription and zero RAM.

The self-hosted version is a front end such as Open WebUI pointed at a local Ollama or at a hosted API. The front end is small software. Expect about 1 GB resident for the chat surface, on top of whatever the model needs. What it does need, and a bare model does not, is a public URL and a certificate, because you want to reach it from a phone: issue the certificate with Certbot and Nginx, or terminate TLS at Traefik in front of several apps. If you are still picking a front end, compare the Open WebUI alternatives.

An assistant answers. It does not act. When it writes a shell command, a person reads that command and decides whether to paste it. That person is a safety layer, and an agent is the thing that removes it.

An agent adds tools and a loop

An agent is an assistant that can call functions and then read the results. Two parts do the work. The first is a tool: a description of a function the model may request, plus your code that actually runs it. The second is the loop: your program calls the model, the model asks for a tool, your program runs it, appends the output to the conversation and calls the model again. That repeats until the model says it is finished or a limit stops it.

The loop is ordinary code, and a basic one fits in under a hundred lines. What makes it an agent is that the tools carry real credentials, so the loop can change something outside itself. That single fact drives every hosting decision below. Agent skills and MCP (model context protocol) servers are two ways to hand an agent more tools without rewriting the loop.

• It outlives your session. A chat ends when you close the tab. An agent run can take twenty minutes and should survive your laptop going to sleep, so it belongs on a box that stays on, started by a systemd service or timer that brings it back after a reboot.
• It holds secrets. An API key, an SSH key, a database password. Anything the agent can read, a hostile instruction hidden in its input can make it use, so keep the secrets out of the agent's reach.
• Its cost grows with the loop, not with your question. Every step re-sends the whole conversation as input, so a ten-step run pays for that transcript ten times. This is why input tokens dominate an agent bill and why you want a hard cap on what one run can spend.
• It can be wrong in a way that writes. A wrong answer in chat costs you a re-read. A wrong delete inside a loop costs you the directory. Run it as a user with the least privilege that still lets it work, and for coding agents, sandbox it before you give it your repository.

What each layer needs from the box

[
  {
    "label": "LLM (weights you host)",
    "ram_gb": 8,
    "gpu": "helps a lot",
    "public_url": "no",
    "credentials": "none"
  },
  {
    "label": "Assistant (chat surface)",
    "ram_gb": 1,
    "gpu": "no",
    "public_url": "yes",
    "credentials": "one login"
  },
  {
    "label": "Agent (tools and a loop)",
    "ram_gb": 2,
    "gpu": "no",
    "public_url": "only for webhooks",
    "credentials": "several"
  }
]

Read the RAM column carefully, because it excludes the model. A chat front end and an agent runtime are both small programs. If the agent calls a hosted model, 2 GB of RAM runs it, and a cheap plan is a real answer rather than a compromise. Put the weights on the same box and the 8 GB model line dominates everything else.

The other columns matter more than people expect. Only the model layer gets faster with a GPU. Only the assistant layer needs a public URL as a matter of course, because a browser has to reach it; an agent needs one only when something outside has to call in, such as a webhook. And an agent holds several credentials, which is the real gap between it and a chat window. A chat window can be wrong. An agent can be wrong and then act on it.

Do you need a GPU to run an AI agent?

No, unless you are also hosting the weights on the same machine. The agent loop is HTTP requests, JSON parsing and subprocess calls, and the CPU sits near idle while it waits on the network. The GPU question is really a question about the LLM layer.

So split the decision. If the text cannot leave your box, pay for the memory to hold a model and, for usable speed, for a GPU to run it. If you only want the automation, rent the model by the token and put the money into uptime and backups instead. Most self-hosted agents in 2026 call a hosted model, and they are cheaper to run for it.

Can you self-host an AI agent?

Yes, and the agent is the layer most worth self-hosting, because the loop is where your data and your credentials live. A small VPS with 2 GB of RAM, a service manager and outbound network access runs a real agent. Take the build-your-own route on a VPS if you want to own the loop, or deploy one of the ready-made self-hosted agents if you would rather start from something finished.

Self-hosting the assistant is easy: it is one container and a certificate. Self-hosting the model is the expensive part, and it is the one people abandon after they watch tokens crawl out of a CPU. Self-host the weights when the data cannot leave the box, or when your volume makes per-token pricing hurt. Otherwise let the agent call an API and keep the interesting parts local.

Is ChatGPT an AI agent?

A chat product becomes an agent the moment it can call a tool and act on the result without asking you first. By that test, hosted assistants with browsing, code execution or connectors are agents. The difference for you is where the loop runs and whose credentials it uses. In a hosted product both belong to the vendor. On your own server both belong to you, along with responsibility for whatever the loop does at three in the morning.

Reactive, planning and multi-agent

Roundups like to list seven types of agent. Most of those types are marketing. Two distinctions change the code you write, and one changes the bill. A reactive agent calls a tool, reads the answer and replies. A planning agent writes a plan first and then works through it, which holds up better on long jobs and costs more tokens, because the plan is re-sent on every step. A multi-agent setup lets one agent start others, and it multiplies token spend and failure modes at the same time, so it pays off only when the sub-jobs are genuinely independent, such as searching four sources at once. Start reactive. Add planning when runs get long. Reach for multi-agent last. For the wider map, see what is worth learning about AI agents in 2026.

How to tell which layer you are actually running

On the server, ask which processes hold the memory.

free -h
ps -eo rss,comm --sort=-rss | head -5

If the top line is ollama or llama-server holding several gigabytes of RSS (resident set size, the memory a process really occupies), you are hosting the model. If nothing is above a few hundred megabytes and your API bill keeps growing, you are hosting an agent or an assistant and renting the model. If that list is empty because everything happens in a browser tab, you are a customer of an assistant, which is a fine place to be until you need software that acts on your behalf.

Which one do you want to run?

• To keep the text private, run the model: self-host an LLM with Ollama, then compare runtimes with Ollama against vLLM once one user becomes ten.
• To own the loop and the tools, build the agent: build your own AI agent on a VPS.
• To have something working this evening, deploy a finished one from the self-hosted agents worth running.
• If none of this has a server under it yet, start at what a VPS actually gives you.

FAQ

Is an AI agent just an LLM with extra steps?

The extra steps are the product. An LLM turns text into text and nothing else. An agent surrounds it with tools it can call and a loop that keeps calling them, and those tools carry credentials, so the output can change a file, a database or a live service. That is why an agent needs a machine that stays on, a service manager and a secrets policy, while an LLM needs only enough memory to hold its weights while it answers.

Do I need a GPU to run an AI agent?

Not for the agent. The loop is HTTP requests, JSON handling and subprocess calls, which any CPU manages while it waits on the network. You need a GPU only when you host the model weights yourself and want more than a few tokens per second out of them. An agent that calls a hosted model runs comfortably on a small VPS with no GPU at all.

How much RAM does a VPS need for an AI agent?

About 2 GB when the agent calls a hosted model, because the runtime, its dependencies and a small local database are all it holds. Add the model on top if you host the weights: qwen3:8b alone wants around 8 GB, so an all-in-one box starts at that mark and climbs with the model you pick.

Can I self-host an AI assistant and keep my conversations private?

Yes, with one caveat that decides everything. A self-hosted front end such as Open WebUI keeps accounts and history on your server. The conversations themselves stay private only if the model behind it is also local. Point the same front end at a hosted API and the text still leaves your box on every message, so you keep the history and not the privacy.

What is the difference between an AI agent and a chatbot?

A chatbot replies and stops. An agent decides what to do next, calls a tool, reads the result and decides again, until the job is done or a limit stops it. The practical test: if the software can change something without a human pressing a button between the answer and the action, it is an agent, and it needs the hosting and the guardrails that come with that.