What an AI agent is, how it works, and where it earns its keep
Plain-language definition first, then the mechanics: how an agent plans, which tools it touches, what it costs, and how to keep it under control.
4-day trial · Cancel anytime
An AI agent is software that pursues a goal on your behalf: it reads the situation through connected apps, plans the steps, acts on real systems, checks what happened, and keeps going until the goal is met or a question needs you. Where a chatbot answers, an AI agent produces outcomes — a sent report, a resolved ticket, an updated database.
Published September 3, 2026 · Updated September 3, 2026 · Loïc Jané
What's new: published September 2026 with a plain-language definition, the five-part anatomy, the agent loop, agent-vs-chatbot distinctions, real cost, and containment guidance.
Sources: Anthropic — Building effective agents · Google Cloud — What is an AI agent? · IBM — Types of AI agents · AWS — What are AI agents? · NVIDIA — AI agents glossary entry · Microsoft Learn — AI agent design patterns
What is an AI agent?
An AI agent is software that uses a language model as its reasoning core, connects to real tools, and carries out multi-step work toward a goal with limited supervision. It decides its own next steps inside permissions you set, instead of following a script you wrote for every case.
The definition has three load-bearing parts. A reasoning core — today a large language model — that turns messy input into decisions. Tools: email, calendars, CRMs, spreadsheets, databases, anything with an interface the agent can call. And a goal plus permissions: what success looks like, and what the agent may or may not touch while getting there. Remove any of the three and you have something else — a chatbot without tools, an automation script without judgment, an unsupervised process without control.
The word 'agent' predates language models by decades — economists and philosophers have long defined an agent as anything that perceives and acts on its environment. What changed in recent years is that the reasoning became general. A thermostat is an agent in the academic sense; an AI agent in the 2026 sense can read an unstructured email, understand what it implies, and decide which of your business systems needs to change because of it.
How does an AI agent work?
Under the marketing labels, every AI agent runs the same loop. Understanding it takes five minutes and changes how you evaluate every vendor claim you will read.
Perceive: it reads its world
The agent starts from context it did not have to be handed: an inbound email, a webhook, a schedule, a database row that changed. Perception is what separates an agent from a script — the input does not have to match a template. A PDF instead of a spreadsheet, a Slack thread instead of a form: it reads what arrived.
Reason: it plans before acting
The language model turns the goal and the context into a plan: which steps, in which order, with what fallback if a step fails. Good agents make this plan visible before acting — you can read what it intends to do and catch a wrong assumption while it is still an assumption, not an action taken on your systems.
Act: it touches real software
Each step executes through a tool: send the email, update the CRM field, query the database, create the calendar event. This is the part chatbots cannot do — an AI agent acts on your systems, not only on your screen. The set of tools it may use is scoped in advance; which ones it needs for a given step is chosen at runtime.
Observe and correct: the loop closes
After each action, the agent reads the result. A query returned nothing — it tries a different filter. A record was ambiguous — it asks you. The loop is what makes agents resilient: the plan is a starting point, not a cage, and unexpected results feed the next decision instead of crashing the run.
Remember: state survives the run
A memory layer persists what happened — notes, references, decisions — so next week's run does not start from zero. In Fleece, each agent keeps a workspace that survives across runs, and agents review their own performance nightly, proposing instruction changes that nothing applies until you approve them.
AI agents, explained without the hype
Two years ago, 'AI agent' described a research concept. Today it is on every landing page, attached to products that range from genuine autonomous software to a text box with a new font. This page is the grounded version: what this kind of software actually is, how the loop works, what it costs to run one, and how to tell the real thing from the label. No invented market numbers, no vendor bingo — the definition, the mechanics, and the honest limits.
The short version: an AI agent is software where a language model does the deciding. Not the drafting, not the summarizing — the deciding. It reads context from your connected apps, forms a plan, executes it through real tools, observes the results, and adjusts. You set the goal and the permissions; the agent works the path between them. That is why agents handle processes with edge cases — the work where a flowchart was never able to hold.
The rest of this page covers the anatomy (five parts, auditable in any product), the distinctions that matter when comparing tools, concrete examples of agents at work in finance, support, sales, and operations, and what one costs to run. When you are ready to go deeper, the cluster continues with autonomous AI agents — how far self-direction can reasonably go — and agent architectures — the four design patterns behind every deployment.
What separates an AI agent from a chatbot, a copilot, and an automation script
Every product now claims to be an agent. The distinctions below are the ones that matter when money, data, or a customer experience is on the line.
A chatbot answers; an AI agent acts. A chatbot's output is text for you to do something with. An agent's output is change in a system: the ticket resolved, the meeting booked, the invoice chased. If a product's every result ends in a message bubble, it is a chatbot — however agent-flavored the branding.
A copilot suggests; you execute. Copilots draft the email, propose the code, outline the report — then wait for your click on every step. An agent owns execution: within the permissions you set, it carries the task to done without a human click per move. Copilots accelerate a person; agents replace a process.
A script follows a path; an agent reads the terrain. Traditional automation — RPA, workflow builders, integration recipes — encodes one route and breaks when reality deviates from it. An agent treats deviation as input: it reads the unexpected email format, decides, and adapts. The trade is real — scripts are cheaper and deterministic; agents buy flexibility with compute.
A scheduled job repeats; an agent handles variance. When the Monday data export is missing two numbers, a cron job ships the report anyway or fails loudly. An agent notices, chases the missing figures, and ships the report with a note about what was absent.
The 'autonomous' label means nothing by itself. Check the three tells: does it hold memory across runs, choose its own tools at runtime, and route irreversible actions through approval gates? Any product missing one of those is an assistant wearing the word autonomous.
The five parts every AI agent is built from
Strip any vendor's branding and an AI agent is assembled from five parts. The list doubles as an audit: ask a vendor how each part is implemented, and you will know within ten minutes whether you are buying an agent or a chatbot with ambitions.
The model — the reasoning core
The language model that reads context and makes decisions. Its quality sets the ceiling on judgment: parsing an ambiguous request, choosing between two plausible actions, knowing when to ask. Different agents on the same platform can run different models — the model is a component you choose per agent, not the agent itself.
The instructions — the brief
The system prompt: the agent's job description, tone, rules, and escalation paths. This is where most agent quality actually lives — a mediocre model with sharp instructions beats a frontier model with vague ones. Good platforms version instructions and let you change them without rebuilding anything.
The tools — the hands
The connected apps the agent may call: Gmail, HubSpot, Stripe, Notion, your database. Tools can be pre-wired per agent or selected at runtime from a catalog of thousands. Runtime selection is the stronger design — it is what lets an agent handle an input format nobody anticipated.
The memory — the notebook
State that persists across runs: what happened last time, which vendor sent which quote, what you told the agent to stop doing. Without memory, every run starts from zero and the agent cannot follow up on anything. Memory is also where personalization lives — the difference between a tool and a colleague.
The guardrails — the leash
The permission system: which apps it may touch, which actions need human approval, spending limits, audit logs. Guardrails are not a brake on capability — they are what make delegation to software trustable at all. A vendor that cannot show you the gates is asking you to run uncontrolled software on your business.
What an AI agent actually does all day
Abstract definitions do not survive contact with a workweek. Here is the same loop running on four real business processes.
Support: from ticket to resolution
A refund request arrives. The agent reads it, looks up the order, checks the refund policy written three months ago, finds the purchase qualifies, and drafts the refund — which waits at an approval gate because money moves. You approve once; the policy rule becomes an instruction; next month the same case closes without you. Average first-response time drops from hours to minutes.
Finance: the Monday numbers, every Monday
Every Monday at 7am, the agent pulls the week's invoices from the billing system, cross-checks payment status against the bank feed, chases the two numbers that never arrive on time by emailing the right person, and posts the cash-flow summary with anomalies flagged. Week one it asked you where everything lived; week four the report is in your inbox before you ask.
Sales: pipeline hygiene nobody wants to do
After every customer call, the agent logs the summary into the CRM, updates the deal stage, drafts the follow-up email for your review, and flags deals that have gone quiet for two weeks with a suggested nudge. The salesperson talks; the paperwork files itself. Nothing is sent without a human click on first contact.
Operations: procurement inbox at zero
Quotes from suppliers land in a shared inbox. The agent extracts prices, delivery terms, and validity dates, compares them against the last three purchases, routes anything above threshold to the right approver with a one-line summary, and files the rest. The comparison table that used to take an intern a Friday afternoon now exists by the time you open the thread.
AI agents for sales — pipeline hygiene and follow-ups in detail
AI agents for customer support — triage, resolution, and escalation paths
AI agents for operations — reporting and monitoring on a schedule
Deploying an agent is the right move when
- The work is multi-step, crosses several apps, and needs judgment — not one deterministic operation on a predictable input
- The process recurs often enough that setup cost pays back within weeks
- Edge cases arrive weekly and currently get handled ad hoc by whoever notices them
- You can name the goal and the permissions clearly — an agent amplifies a clear brief and a vague one equally
A script is still the better answer when
- The task is one fixed operation on a clean, predictable input — write the script, it is cheaper
- You cannot yet describe the process — map it by hand first; the map is the brief
- A compliance rule pins every step and forbids deviation — a rigid path is a feature there, and an agent is the wrong tool
The platform buyer's checklist — how to evaluate what a vendor's 'agent' really is before you pay
What AI agents get wrong, and how you contain it
The first risk is confident error. A language model can misread a request and act on the misreading — refund the wrong amount, email the wrong person, route a ticket to the wrong queue. Containment is structural, not hopeful: every irreversible action sits behind an approval gate until the run log proves the agent handles the case class, and every decision is traceable. You are not prevented from automating; you are shown exactly when it is safe to.
The second risk is runaway execution. An agent that loops — retrying a failed step, delegating back and forth with another agent, or 'helpfully' expanding scope — burns credits while producing nothing. Production agents need step budgets, loop detection, and a hard stop. This is engineering, not configuration luck: ask any vendor what stops a run that goes sideways at 3am, and judge the answer's specificity.
The third risk is data exposure. An agent with read access to your CRM, inbox, and spreadsheets is a system holding your business's context — permissions must be scoped per agent, credentials must never sit in prompts, and logs must record every tool call. The honest summary: an agent is as safe as the guardrails around it, and the guardrails are a product feature you should evaluate as hard as the model.
How Fleece AI implements AI agents
Fleece agents are AI agents in the full sense above: a chosen model as the reasoning core, plain-language instructions you edit any time, runtime tool selection across 3,000+ apps, a persistent workspace as memory, and approval gates plus audit logs as guardrails. Nothing is simulated in a sandbox — agents act on your real systems, inside the permissions you set.
Agents can also work as a team: a manager agent delegates to specialist sub-agents in a hierarchy capped at three levels, each with its own goal, tools, and workspace. Delegation depth and per-agent scoping are enforced by the platform — the coordination failure modes are engineered out, not promised away.
Supervision is a dial, not a switch. Start an agent with every external action gated; open the gates as the run log earns trust; let the nightly self-review propose instruction changes and approve only what you like. The path from 'an assistant that drafts' to 'a process that runs' is the same agent, with progressively loosened permissions.
Pricing is public and credit-based: a free plan to build your first agent, then paid plans from €49/month (Starter: 5 agents, 10 flows, 2,000 credits). You pay for runtime, not per seat — an agent that runs quietly all week costs a fraction of one processing thousands of tickets.
Read the docs — how agents, tools, and approval gates are configured
Browse the API reference — run agents programmatically over the REST API
Frequently asked questions
It is software that does work for you instead of just talking about it. You give it a goal and access to your tools; it reads the situation, plans the steps, acts on real apps, and checks its results. A chatbot answers questions; an agent completes tasks across your systems.
It runs a loop: perceive, reason, act, observe. It reads incoming context — emails, triggers, schedules — plans which steps reach the goal, executes them through connected apps, reads each result, and corrects course when something unexpected comes back. Memory persists across runs so it can follow up on earlier work.
A chatbot produces text and waits for you to act on it. An AI agent produces outcomes: it can send the email, update the CRM, issue the refund, and book the meeting itself. The chatbot ends its turn with a suggestion; the agent ends its run with the task done and a record of what it did.
Concrete examples: resolve support tickets by checking orders and policies, compile weekly financial reports with missing data chased down, keep CRM records current after every call, and process supplier quotes into comparison tables. The common shape: multi-step work across several apps that needs judgment, not one fixed operation.
It depends on runtime volume. Fleece has a free plan to build your first agent, and paid plans from €49/month (Starter: 5 agents, 10 flows, 2,000 credits/month) up to €199 for Business. You pay for credits consumed by runs — a quiet one costs little; one processing thousands of tickets costs proportionally more.
They are as safe as their guardrails. Look for three things: scoped permissions (each agent touches only its apps), approval gates on irreversible actions like payments and sends, and audit logs recording every tool call. With those in place, the system is more accountable than the ad-hoc human handling it replaces — every decision is traceable.
No. You describe the goal and the rules in plain language, connect the apps the agent should use, and set who approves what. Fleece proposes the plan and the tool set; configuration is selection, not programming. Code matters only if you want programmatic control — everything is also available over a REST API.
Put an AI agent to work
Describe the goal in plain language. Fleece builds the agent, shows the plan, and asks before anything irreversible — start free and loosen the permissions as the run log earns your trust.
Powered by Fleece AI · autonomous agents for 3,000+ apps