Your Chatbot Hands You a Draft. An Agent Hands You the Finished Thing.
Chatbots hand back answers, agents hand back finished work. The five capabilities that separate them, where the popular tools sit, and how to test one.
Ask a chatbot to "sort out the weekly client report" and you get something impressive back: a structure, a draft, maybe a nicely formatted table. Then you copy it into Google Docs. You pull the real numbers out of the analytics dashboard, because it does not have them. You fix the two figures it guessed at. You attach it to an email. You send it.
The model did the interesting ten percent. You did the ninety percent that was actually the job.
That gap is the whole difference between a chatbot and an agent, and it is not a difference in intelligence. Very often it is the same model underneath — the thing that changed is what the software around it is allowed to do.
The one-line test
A chatbot's output is a message. An agent's output is a changed state of the world.
Everything else follows from that. If the deliverable is text in a window, a human has to carry it the last mile. If the deliverable is a row written to your CRM, a file in your drive, a scheduled report that arrived at 6am on Monday — nobody carried anything.
So when you are evaluating one of these things, the question to ask is not "how good are its answers?" Answers have been good for a while now. The question is: what does it still need me for?
For the broader definition of the category, we wrote what an autonomous AI agent is separately. This post is about the machinery — the five things a system genuinely needs before "answer" becomes "done".
1. It can write, not just read
The first fork in the road is permissions. A chatbot with web browsing can read your world. An agent can change it: create the issue, send the invoice, update the record, book the room.
That sounds like a small step and is in fact the hardest one, because writing is where the consequences live. Reading a Stripe dashboard wrongly costs nothing. Issuing a refund wrongly costs money. So the interesting part of an agent platform is not that it can write — it is the plumbing around the writing: which account it acts as, which specific actions it is allowed to take, and what it does when a credential dies.
In practice this is what the Model Context Protocol standard is for — a common way for a model to call a real tool in a real product. Burrak connects to vendor-hosted MCP servers over OAuth, so an agent acts as you, inside the permissions you already have, and you can revoke it in one click: Linear, Notion, Jira and Confluence, GitHub, Stripe, Airtable, Sentry, Google Calendar and dozens more. No API keys pasted into a prompt box.
The chatbot equivalent — pasting a summary into the tool yourself — is not a smaller version of this. It is a different product.
2. It runs when you are not there
Chat is synchronous by construction. The work happens while you watch it happen; close the tab and it stops. That is fine for thinking out loud, and fatal for anything that takes forty minutes.
An agent has to survive your absence. That means the run lives somewhere durable, not in a browser tab, and it means work can be scheduled rather than triggered by you typing. "Every Monday at six, pull last week's numbers, write the summary, put it in the shared folder, message me if anything moved more than ten percent" is not a prompt. It is a standing instruction, and something has to be awake to honour it.
This is the honest weakness in the self-hosted agent tools, which are otherwise excellent. Hermes Agent runs on your machine — genuinely open source, deeply configurable, free beyond model costs, and asleep the moment your laptop lid closes. You can put it on a server, and then you are running a server. Burrak's remote agents run on managed infrastructure, metered by the day rather than by the hour you happened to be at your desk, which is the trade: less control, no infrastructure.
3. It remembers between jobs, not just within one
A chat thread has excellent memory and no continuity. Everything you established — the brand voice, the client's naming conventions, that finance wants the figures net not gross — evaporates when you open a new conversation. The thirtieth report costs exactly as much of your attention as the first.
Two mechanisms fix this, and they do different jobs.
Memory is what carries forward across runs: preferences, corrections, facts about your business the agent learned the hard way last month.
Roles are what an agent is before you ask it anything. Burrak ships 239 pre-built roles in the marketplace — Financial Analyst, SEO Specialist, DevOps Engineer, Accounts Payable — and the role text goes into the system prompt of every run, including scheduled ones. You are not re-explaining the job each time; you hired for it once.
The test here is simple: if you have to re-paste your context at the top of every session, you are still doing the work.
4. It notices when it got it wrong
This is the least discussed and possibly the most important one.
A chatbot that is confidently wrong is a minor irritation, because you are sitting right there reading the answer. An agent that is confidently wrong is a real problem, because it already sent the email.
An autonomous run therefore needs a notion of failure that goes beyond "the code did not crash". Burrak's tasks have an optional verification step: a second model pass judges the output against what was actually asked, PASS or FAIL. On FAIL, the task retries with the critique attached — up to three attempts — and if it still cannot get there, you get the best attempt back explicitly flagged as unverified rather than quietly filed as a success. You also get the full transcript, verifier turns included, so you can see how it reasoned rather than trusting a green tick.
Any agent you evaluate should be able to answer: what happens on attempt two? If there is no answer, you are the error handler.
5. It is accountable — in money and in audit trail
Chat costs are invisible and small. Autonomous costs are neither, because the whole point is that it works without you watching. So an agent needs a meter you can read, a per-task choice of model (a scheduled file-tidying job does not need your most expensive reasoning model, and a legal summary should not run on your cheapest), and a record of what it did while you were away.
If you cannot answer "what did it spend, and on what?" the following morning, that is a product gap, not a pricing detail. Our pricing page sets out how credits work.
Where the tools you know actually sit
None of this is a ranking. These are different products that get lumped together, and the useful thing is knowing which shelf each one is on.
ChatGPT, Claude, Gemini, Copilot. The best answer-generators in the world, and increasingly agentic in a bounded way — deep research modes will run for minutes and come back with something substantial. But the artefact is still a document handed to you in a window, the run belongs to a session, and by design very little of your business is wired up for it to change. Reach for them for thinking, drafting, explaining, deciding. Use them, honestly, alongside an agent rather than instead of one.
Zapier, Make, n8n. These do complete tasks end-to-end, and for a fixed, high-volume, well-understood path they will beat an agent on both cost and reliability — a deterministic pipeline that has run ten thousand times is a better tool than a model deciding afresh each time. What they cannot do is handle the branch you did not anticipate. Their strength is that they do exactly what you drew; their weakness is the same sentence. If you can draw the flowchart, build the zap. If step three is "read this and use judgement", you need a model in the loop.
Cursor, Claude Code, and the coding agents. Fully agentic, and better at their domain than any generalist — they plan, edit files, run tests, iterate. The boundary is the domain and the machine: they live in a repository on your computer, in your session. Excellent at code, not aimed at your invoicing. We compared the coding tools in detail if that is your use case.
OpenClaw, Mira, and the messaging assistants. Clever product insight — put the AI where people already are, in Telegram or Discord — and they do take real actions. But the chat window is still the interface, which means the interaction stays conversational and mostly synchronous. More on that trade-off here.
Burrak. Managed agents that hold a role, keep memory, connect to your real tools over OAuth, run on a schedule without you, verify their own output, and report to you on web, desktop, CLI or the Android app. iOS is on its way. The cost of that convenience is that it is a proprietary managed platform: you cannot read the source, you cannot self-host it, and remote runs need connectivity.
When you should just use a chatbot
Agents are not the upgrade path for everything, and pretending otherwise is how people end up disappointed.
- Quick questions. If the answer is the deliverable, an agent adds latency and cost for nothing.
- Thinking out loud. Strategy, naming, arguing with your own reasoning — that wants a fast back-and-forth, not a job queue.
- Anything irreversible you have not yet built trust for. Send the money, delete the records, publish to production — keep a human on the button until you have watched it do the safe version of that job a few times.
- Work whose standard you cannot articulate. An agent optimises for the goal you gave it. If you cannot say what "good" looks like, neither the agent nor the verifier can check it, and you will be re-reading everything anyway.
The pattern that works is the boring one: chatbot for thinking, agent for the repeated shape of work you have already thought through. Most people's weeks contain a surprising amount of the second thing — ten of the usual suspects here.
How to tell them apart in five minutes
Give the candidate a job with a real ending. Not "write me a competitor analysis" — that is a chatbot prompt wearing a costume. Try:
"Check our three competitors' pricing pages, note anything that changed since last month, put the summary in a doc and put a reminder in my calendar to review it on Friday."
Then close the laptop.
Four questions when you come back. Did it reach the actual tools, or describe what it would have done? Did it finish without you? Did it catch its own mistake, or hand you a confident wrong answer? And can you see what it did and what it cost?
A chatbot fails the first question. Most things marketed as agents fail the third.
Try it on a real task → — free to start, no credit card. Pick a role, connect one tool, give it something with an ending. If you would rather watch first, the video tutorials walk through setup end to end.
Tags: AI agents vs chatbots, autonomous AI agent, end-to-end task automation, AI agent comparison, Burrak AI