AI agent vs AI assistant: the difference and what to pick for a task

The words "model", "assistant" and "agent" are often used as synonyms in conversations about neural networks, though they stand for different things with different costs and risks. If you are choosing a tool for a task and want to understand the difference between an AI agent and an AI assistant, start with three levels: the model itself, the assistant around it, and the agent that acts. Below is an explanation with examples, a comparison table, a small code example and a rule for when a plain chat is enough.

Three levels: model, assistant, agent

The model (LLM)

A language model receives text and returns text. Everything else is built around it. Through an API it does not remember previous requests: you send the dialogue history again each time. If someone asks "AI agent vs LLM", the answer is: the LLM is the "engine" and the agent is the "car" with a steering wheel, fuel and a route.

Examples of models from the Zukko catalog: claude-sonnet-5-5, gpt-6.1-sol, deepseek-v4.1-flash. One key lets you call any of them.

The assistant

An assistant is a model plus dialogue scaffolding: a system instruction ("you are a support helper"), history storage, a chat interface. It answers questions, writes and edits text, explains code. But the actions remain yours: it advises, you do. A classic chat in the browser is an assistant.

The agent

An agent is a model given tools and a goal. It chooses the next step itself, calls a tool (read a file, run a query, run tests), looks at the result and decides what to do next, until it considers the task done or hits a limit. The loop looks like this:

1. The model receives the goal and a list of available tools.
2. It replies either with text (the task is finished) or with a request to call a tool.
3. The program executes the tool and returns the result to the model.
4. Steps 2-3 repeat until it stops.

In short, what an AI agent is: a program where the model makes decisions in a loop rather than answering a single request once.

Comparison

Practical examples

"Explain the error in this stack trace." You paste the text and get an explanation. This is an assistant task: one request, no actions outside the chat.

"Find out why the test fails and fix it." You need to read files, run the test, make an edit, run again. This is agent work, for example Claude Code or opencode. A person can do these steps by hand through a chat, but has to copy results back and forth.

"Reply to the customer using a template." An assistant with a good instruction. An agent is not needed here; it would only add risk and spend.

"Once a day collect new requests from the spreadsheet, check duplicates and send a report." Automation. An agent is not required: when the order of steps is fixed, an ordinary script that calls the model at the right places is more reliable. It becomes an agent when the steps are not known in advance.

A minimal agent example

To see the line between an assistant and an agent, a few dozen lines are enough. Here the model has one tool, reading a file, and a hard ceiling on the number of steps:

import json
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key=os.environ["ZUKKO_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "read_file",
        "description": "Read a text file by path",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},

Without the loop this would be an assistant: one request, one answer. The loop with tools turns it into an agent. Real agents add a sandbox, confirmations and spend tracking, and this example has no path validation, so it must not be used on real data. A full walkthrough is in How to build an AI agent in Python from scratch↗.

What to pick for a task

Ask yourself four questions:

1. Do you need to perform actions, not just get text? If not, take a chat or a plain model call from code.
2. Is the order of steps known in advance? If so, write a script and call the model at the right points: cheaper and more predictable.
3. Can you limit the agent's scope of action? If not (no sandbox, no backups), start with an assistant.
4. Is there a way to check the result? An agent that runs tests itself can correct itself. An agent without verification is confidently wrong.

More on how ready-made agents are built is in the article What an agent harness is↗.

What the difference costs

An assistant pays for one request, while for an agent tokens multiply by the number of steps: on each step the accumulated context is sent to the model again. An agent that makes 20 steps calls the model 20 times. So three things matter for an agent: a step ceiling, a spend limit on the key and a model suited to the task. A real step-by-step calculation with a formula is in What an hour of agent work really costs↗.

Beginners should start with the beginner documentation↗: it explains how to get a key and make a first request. You can create a key in the Zukko dashboard↗. One key works with Claude, GPT, Gemini, DeepSeek, Qwen and GLM models.

FAQ

Is an agent always better than an assistant?

No. An agent is useful where the task consists of several dependent actions. For questions and texts it is excessive, costs more and adds the risk of unwanted actions.

How does an agent differ from a script that calls a model?

In a script the programmer sets the order of steps. In an agent the model chooses the order as it works. If the order is known in advance, a script is more reliable and cheaper.

Does an agent need a special model?

The model must support tool calling. Which one copes best depends on your task: compare by price, context and intelligence index from the catalog and test on your own examples.

How do I keep spend under control?

Set a ceiling on the number of steps, use a separate key with a daily limit, and watch spend on the Usage page.