Skip to main content

Agents vs Assistants

info

This content was developed with AI assistance and is regularly reviewed for accuracy.

Snapshot: October 2026. Model names, prices, and product features change monthly; What's New in AI is the maintained chronology.

By 2026 every major assistant can search the web, read your files, remember what you told it last month, and act through connected apps. So the old test for an agent, "does it use tools?", no longer separates anything. The difference that matters now is who drives: an assistant answers and drafts while you carry out the steps; an agent takes the goal, plans the steps, runs them, checks the result, and comes back to you at the points you marked for approval.

Understanding that line is the first skill in this track, because it tells you what to delegate, what to keep in the chat, and what to keep away from AI altogether.

The simple definition​

AspectAI assistantAI agent
InteractionQuestion, answer, your next questionGoal, plan, execution, report
TurnsYou drive each stepThe agent drives; you approve the risky ones
ToolsUsed when you ask (search, a file, a connector)Chosen and chained by the agent as the task needs
OutputText, a draft, an answerA completed task: files changed, messages sent, a PR opened
Where it stopsAfter every replyAt a stop condition or an approval gate you set

Both run on the same models. Claude, GPT-6, and Gemini 4 all power both patterns. The model is not what makes something an agent; the loop and the permissions are.

Two scenarios​

Competitor pricing research​

Assistant approach. You ask for a comparison of five competitors' pricing. The assistant searches, summarizes what it found, and flags what it could not verify. You open a spreadsheet, copy the figures across, and tidy the formatting. Next month you do it again.

Agent approach. You hand over a brief:

Research the current pricing pages of [competitor 1-5]. Build a spreadsheet with
tiers, prices, and limits per competitor, mark anything you could not confirm on
the vendor's own site as UNVERIFIED, and save it as [competitor_pricing.xlsx].
Repeat every Monday and tell me only what changed.

The agent opens each page, extracts the figures, creates the file, and reports. Scheduled, it reruns without you and flags the differences. The work you keep is the ten-minute review of what changed.

A failing login​

Assistant approach. You paste an error message. The assistant suggests checking the database connection. You check; it is fine. It suggests the authentication middleware. You test; still broken. Three rounds later you have a fix, and you ran every command yourself.

Agent approach. You tell a coding agent to fix the login error in staging. It reads the logs, traces the code path, identifies a token-expiry bug in the auth middleware, writes the fix, runs the test suite, and opens a pull request with an explanation. You review the diff and merge, or send it back.

The second pattern is faster when the task is well bounded and the cost of a wrong step is low or reversible. It is slower, and sometimes dangerous, when neither is true. The rest of this page is about telling those cases apart.

The four pillars of agency​

1. Autonomy​

An assistant waits for your next instruction. An agent decides the next step itself. Given "send the weekly metrics report to the team on Friday," an agent pulls the numbers, drafts the report, and sends it, pausing only where you told it to pause. Autonomy is what saves you time, and it is also the property every safety control exists to bound.

2. Tool use​

Agents reach into systems to get things done: the web, code execution, files and repositories, and business systems through connectors. In 2026 most of those connectors are built on the Model Context Protocol (MCP), an open standard governed by the Agentic AI Foundation under the Linux Foundation. One MCP server per system, usable from Claude, ChatGPT, Gemini, and most coding agents. What matters for you is not the protocol but the scope: each connector you grant widens what the agent can read and change. The MCP sub-track covers both the user view and the builder view.

3. Memory and state​

Assistants remember too now, so this pillar is about state across a task rather than recall across chats. An agent carries what it learned in step three into step seven, keeps project context across sessions, writes intermediate results to files it can pick up again, and loads reusable skills and instructions on demand. A long-running agent that loses its thread halfway through a task is the most common way agents fail quietly, which is why the Loops sub-track spends a whole page on context resets and handoffs.

4. Adaptation​

An assistant follows your prompt as written. An agent notices when reality does not match the plan and changes course: a test fails, so it reads the error and tries again; a web page layout changed, so it re-inspects and adjusts; you reject a draft, so it asks what to change and produces another. This observe, decide, act, observe-again loop is what separates an agent from a script. It is also why an agent can wander, and why every agent needs a stop condition.

When to use which​

An agent is the right choice when a task is multi-step with a repeatable shape, bounded (the goal, inputs, and success criteria can be stated in a paragraph), tolerant of iteration (the agent can try, fail, and retry without causing harm), and high-leverage (the time saved justifies the setup and review).

Stay with an assistant, or do it yourself, when the task is a genuine one-off, when a mistake would be severe and irreversible, when the task needs a human judgment call rather than execution, or when you need an auditable, predictable sequence every time. That last case is often better served by a plain workflow than by an agent; When a Workflow Beats a Loop makes the case in detail.

A useful habit before delegating anything: ask what the worst plausible outcome is if the agent misreads the goal. If the answer is "I lose ten minutes," delegate. If the answer involves money, deletion, or a message you cannot unsend, keep an approval gate in the loop or keep the task for yourself.

The bottom line​

A chat window is an assistant. The same model, given tools, state, autonomy, and a goal, is an agent. In 2026 the default has flipped: for repeatable knowledge work, the question is no longer "what should I ask?" but "what should I delegate, and where should it stop and check with me?"

Key takeaways​

  • The difference is who drives. Assistants answer; agents plan, act, check, and loop until a stop condition.
  • The four pillars are autonomy, tool use, state across a task, and adaptation. Each one is a capability and a risk.
  • Delegate tasks that are multi-step, bounded, iteration-tolerant, and high-leverage. Keep irreversible or judgment-heavy work closer.
  • A predictable, auditable sequence is often a workflow problem, not an agent problem.

From the author​

Want to watch an agent like the pricing-research one work without building anything? FreshVisit, by the author of this site, is a browsing agent you can hand a task to. It opens a real browser, decides what to click at each step, and shows you every screen it visited on the way to an answer. It is the clearest demonstration of the four pillars above that you can try in a minute.

Next steps​