The three kinds of AI agent, in plain English
AI agents come in three shapes. A sequential agent runs a fixed order of steps, like an assembly line. A reactive agent decides what to do next based on what it finds. A planning agent works out the whole plan before it starts. Most business jobs are best served by the simplest of the three, and that is almost always sequential.
An agent is not a chatbot
A chatbot answers a question. You ask, it replies, and you are still the one who does the work. An agent is different in one specific way: it is given a job rather than a question, and it is given permission to use tools to finish it.
What that looks like underneath is a loop. The agent works out what to do next, does it, looks at what came back, and decides again. It keeps going until the job is done or until it gets stuck. The published technique behind most of this is called ReAct, short for reason and act, and the name describes it accurately: the thinking and the doing alternate rather than happening once.
The practical consequence for a business is that an agent can finish something. Not suggest it, not draft a reply for you to send, but actually walk a task across the three or four systems the task really lives in and come back with it done. That is more useful and more dangerous than a chatbot, which is why the rest of this article spends as much time on the limits as on the uses.
The three kinds
Agents are usually built to one of three patterns. The difference is not the technology, it is how much freedom the agent has to decide the order of its own work. That single choice drives the cost, the predictability and how easy it is to explain what happened when something goes wrong.
Sequential agents run a fixed order of steps. Step one, then step two, then step three, every time. They are the assembly line of the three. Reactive agents decide in the moment. They look at what is in front of them and ask what to do next, rather than following a set path. Planning agents pause before they start, work out the whole sequence, and then carry it out. That last one is the right answer when the steps depend on each other and you cannot know the order until you have looked.
| Sequential | Reactive | Planning | |
|---|---|---|---|
| How it works | A fixed order of steps | Decides the next step each time | Writes the whole plan, then runs it |
| Best for | Jobs that are the same every time | Messy or unpredictable input | Multi-step goals with dependencies |
| Predictability | High. Same input, same path | Medium. Path varies by case | Medium. The plan is visible first |
| Cost to run | Lowest | Higher. More decisions to make | Highest. It thinks before it acts |
| Ease of audit | Easy. One path to check | Harder. Every run differs | Moderate. The plan is a record |
| Typical job | Invoice arrives, is read, is posted | An enquiry is triaged and routed | A quote is assembled from several sources |
| Where it fails | An exception it was not built for | Looping, or an odd choice nobody predicted | A confident plan built on a wrong assumption |
What each one looks like in a real business
Sequential. A supplier invoice arrives by email. The agent reads it, pulls out the supplier, date, net, VAT and purchase order reference, checks it against the order, and posts it to the ledger. Anything that does not reconcile is held for a person. The same five steps run every time, in the same order, which is exactly why this is the pattern most businesses should start with.
Reactive. An enquiry arrives and could be any of a dozen things: a new sale, a complaint, an invoice query, a job application, a supplier chasing payment. The agent reads it, works out what it actually is, attaches the relevant history and puts it in front of the right person with a draft reply already written. There is no fixed path here because the input decides the path.
Planning. A customer asks for a quote covering several products, each with different lead times, stock positions and pricing rules. The agent works out what it needs to check and in what order, because checking stock before confirming the specification would waste the effort. Then it carries the plan out. Travel booking is the textbook example, but assembling a quote or scheduling a multi-trade job is the same shape.
How much freedom should it have?
This is the decision that matters most and the one suppliers skip. Agents are not autonomous or not autonomous. There is a dial, and where you set it should depend on how expensive a mistake is, not on how impressive the demonstration looks.
It suggests. The agent tells a person what it would do and does nothing. Useful while you are learning to trust it, and genuinely useful forever for anything high stakes.
It drafts. The agent does the work and a person sends it. The reply is written, the quote is assembled, the entry is prepared. This is where most of the value in a small business sits, because the slow part was never the sending.
It acts, with approval on the part that matters. The agent completes the whole job but stops before the irreversible step. It posts the draft invoice but does not pay it. It prepares the refund but does not issue it.
It acts alone. Only for work where a mistake is cheap and reversible. Filing, tagging, sorting, internal notifications. Not payments, not anything a customer sees, not anything you would have to apologise for.
Most businesses we work with end up running at drafts and acts-with-approval, and move a job to acting alone only after months of watching it get the answer right. That is the correct order. Trust is earned by evidence, and you will have the log to show it.
Agents that work together
The second thing that surprises people is that a good agent system is usually several small agents rather than one clever one. It works the way a small team works: somebody breaks the job into pieces, somebody does each piece, somebody checks the result, and one person coordinates the whole thing.
In practice that is a coordinator which receives the job and decides who does what, one or more specialists which each do a narrow piece well, and a checker which verifies the output before it goes anywhere. Each part is small enough to test on its own.
The reason to care, as the person paying, is diagnosis. When one large agent produces something wrong, you know only that it is wrong. When a system of three produces something wrong, you can see whether the plan was bad, the work was bad, or the check failed to catch it. That is the difference between a fix that takes an afternoon and a rebuild that takes a fortnight.
It is also cheaper to change. Adding a new document type to a specialist is a small job. Retraining a monolith to handle one more case is not.
Which one you actually need
Start with the dullest pattern that does the job. The temptation is always to build the clever one, and the clever one is harder to predict, more expensive per run and much harder to explain to a client or an auditor six weeks later.
A short test. If you can write the steps down in order and they are the same every time, you want a sequential agent, and you may not need an agent at all: ordinary automation may be cheaper and easier to audit. If the first thing a person does is work out what kind of thing has arrived, you want a reactive agent. If the order of the work genuinely depends on what you find, and getting the order wrong wastes real effort, you want a planning agent.
Most of the jobs we are asked about turn out to be sequential once someone has written down what actually happens. That is not a disappointing answer. The sequential ones are the cheapest to run, the easiest to trust, and the ones that survive being handed over to your own team.
How a good agent checks its own work
The useful part of modern agent design is not the reasoning, it is the checking. A well-built agent has a second step that inspects what the first step produced and asks whether it meets the requirement. If it does not, the work is sent back and tried again.
Two details matter to you as the person paying for it. First, the check has to be a real test, not the agent marking its own homework in general terms: "does this output contain every field we need, in the right format" is a test, "is this good" is not. Second, the retry has to be capped. An agent allowed to correct itself indefinitely will either loop forever or spend your money doing it. Three attempts, then hand it to a person, is a sensible default.
The same principle explains why several small agents often beat one large one. A planner that produces the outline, a worker that fills it in, and a checker that verifies the result is easier to test and easier to fix than a single agent asked to do all three, because when something is wrong you can see which part was wrong.
Where agents pay off in a small business
Large companies buy agents to handle scale. Small and medium businesses buy them for a different reason: because one or two people are carrying a job that has no business taking a person's day, and there is nobody spare to hand it to.
That changes what is worth automating. The best first job in a small business is usually not the most visible one. It is the one that a single person does, that takes hours a week, that involves reading something and typing it somewhere else, and that has a clear right answer. Those jobs exist in every department and they are almost always invisible on the org chart.
The table below is the shape of it. Read it looking for the row that made you wince.
| Area | The job that eats the time | Pattern | What changes |
|---|---|---|---|
| Finance | Reading supplier invoices and statements into the ledger, chasing what has not been paid | Sequential | The purchase ledger keeps itself current, and only the exceptions reach a person |
| Sales | Working out what an enquiry is, finding the history, writing the first reply | Reactive | Enquiries are answered the same day instead of when somebody gets to them |
| Quoting | Pulling a price together from stock, lead times and pricing rules that live in different places | Planning | Quotes go out in hours rather than days, and the arithmetic is consistent |
| Customer service | Answering the same questions, then routing the rest to the right person | Reactive | Routine questions are handled, including out of hours, and the hard ones arrive with context attached |
| Operations | Checking deliveries against orders, spotting the discrepancies | Sequential | Problems surface the same week rather than at month end |
| Admin and HR | Onboarding paperwork, policy questions, timesheet chasing | Sequential | The same answer every time, and nobody interrupts the one person who knows |
| Marketing | Turning what you already have into the next piece, from your own material | Sequential | Drafts exist to edit instead of blank pages to fill |
Picking the first one
Pick the job that takes the most hours and has the clearest right answer. Not the one that would impress a customer. The saving is easy to measure, a mistake is easy to spot, and nobody outside the business sees you learning.
Three questions settle it. How many hours a week does this take, and whose? If the agent got it wrong, how quickly would somebody notice? And is there already a rule for what the right answer looks like, or does it depend on judgement nobody has written down? A job with a lot of hours, fast detection and a written rule is the one to start with.
The jobs to leave until later are the customer-facing ones, anything where a mistake is expensive to undo, and anything where the process changes every few weeks. Those are all doable. They are just a poor place to learn.
What you actually get out of it
The honest benefits are unglamorous and they are mostly about time and consistency rather than intelligence.
Hours come back, and they come back from the specific people doing the specific job, which is why it is worth measuring the job before you start. The transcription errors go away, because nothing is being retyped. The work happens at the same standard on a Friday afternoon as on a Monday morning. It can run outside your hours, so things that used to wait until Monday are already done. And because every step is logged, you gain something most manual processes never had: a record of exactly what was done and why.
What you do not get is a reduction in headcount, and you should be sceptical of anyone selling that. In the work we do, agents remove tasks rather than roles, and the tasks they remove are the ones nobody wanted. If a supplier is pitching staff savings, ask them who checks the output when it is wrong.
What it costs, and how a project should be shaped
There are two costs and suppliers tend to quote only the first. There is the cost to build it, which is a project, and the cost to run it, which is monthly and forever. An agent that makes a decision on every record costs more to run than one that follows a fixed path, which is another reason the dull pattern usually wins.
The shape a sensible project takes is small first. One job, scoped tightly, priced as a fixed piece of work, measured against your own real examples. At the end of it you know three things you did not know before: whether the saving is real, what the running cost looks like at your volumes, and whether your data is in good enough shape. If the answer is that it does not pay, you have found that out for the price of a pilot rather than a programme.
Anything quoted as an open-ended engagement before anyone has proved the first step is a warning sign. So is a price that does not separate build from run. Ask for both, in writing, before you start.
Where agents go wrong
No checkpoint before something irreversible. The failures that make the news are always an agent allowed to send, pay or delete on its own. Drafting can be automatic. Anything that leaves the building or moves money waits for a person.
No audit trail. If you cannot answer "why did it do that" six weeks later, you cannot defend it to a client, an auditor or the ICO. The log has to be readable by someone non-technical.
The wrong pattern for the job. A reactive agent doing work that was always sequential costs more, varies without reason and is harder to check. This is the most common design mistake we see.
Scope that grows because it can. An agent that starts as one job and becomes five is the usual way these projects fail. One narrow agent that works beats a general one that nearly works.
How we build them
We are a London AI and software development company and we have built for UK clients since 2015. Agents are one part of that. We also build the automation, the document extraction and the integrations that agents usually sit on top of, which matters, because an agent is only as good as its access to your systems.
How we work on this is deliberately unexciting. We sit with whoever does the job, because the process in the manual and the process on the floor are rarely the same. We pick the narrowest version that would still be worth doing. We agree what success is measured in before anything is built. Then we prove it on one real job at a fixed price, and you decide whether to go further with actual evidence in front of you.
Everything we build has a person in the loop wherever the consequence is irreversible, a log in plain language rather than a developer console, and a cap on how many times it will retry before it asks for help. You own the code, the configuration and the prompts. There is no lock-in, and we will tell you when ordinary automation would do the job better and cheaper than an agent, because that happens often.
If there is a job in your business that eats hours and has a clear right answer, that is the conversation worth having. It costs nothing to find out whether it is a good candidate, and we will say so plainly if it is not.
Common questions
A chatbot answers a question and leaves the work with you. An agent is given a job and permission to use tools, so it can carry a task across several systems and come back with it finished. Agents are more useful and carry more risk, which is why anything irreversible should still go through a person.
Sequential, by a clear margin. It follows a fixed path, so it makes fewer decisions and uses less processing per run. Reactive agents cost more because they decide at every step, and planning agents cost most because they think before they act.
Often ordinary automation, and a supplier should tell you so. If the steps are the same every time and no step needs judgement, rules are cheaper, faster and far easier to audit. Agents earn their place when a step needs reading something unstructured or deciding between options.
By not giving it the ability to. An agent should only hold the permissions its one job needs, anything irreversible should require a person to approve it, and self-correction should be capped at a small number of retries rather than left to run.
Yes, and it is usually the better design. A planner, a worker and a checker are easier to test and fix than one agent doing all three, because when the output is wrong you can see which part was responsible.
Set it by how expensive a mistake is, not by how impressive the demo looks. Most business agents should draft the work for a person to send, or complete the job and stop before the irreversible step. Acting entirely alone is only sensible where a mistake is cheap and quickly reversible, such as filing or tagging.
There are two costs and suppliers often quote only the build. Running cost depends on how many decisions the agent makes per record, which is why a sequential agent is markedly cheaper to run than a reactive or planning one. Ask for build and run priced separately, in writing, before you start.
The job with the most hours and the clearest right answer, which is usually in finance or admin rather than anywhere a customer can see. Leave customer-facing work until later: it is perfectly doable, it is just an expensive place to learn.
Decide the measure before you build it. For most jobs that is hours taken out of a named task, the error rate against a sample a person checks, and how often the agent stops and asks for help. If nobody can name the measure, the project is not ready to start.
Where to go next
Want a straight answer about your own setup?
Tell us what you are running now and what is going wrong with it. We will say what we would do, including when the answer is that you do not need us.