In plain English
What an agent is, what goes wrong, and why any of this exists. No code.
This page has no code on it. If you're evaluating agentFast, explaining it to a colleague, or you just want to know what the thing does before you install anything — start here.
What an AI agent actually is
A chatbot answers questions. An agent does things.
Ask a chatbot about a refund and it explains the refund policy. Ask an agent, and it looks up your order, checks the policy, decides you qualify, and issues the refund. It takes actions in the real world — sending emails, moving money, changing records, opening tickets.
That difference is the whole story. A chatbot that gets something wrong wastes someone's time. An agent that gets something wrong has already done it.
The gap nobody warns you about
Building an agent that works in a demo takes an afternoon. Building one you'd let near a real customer takes months, and almost none of that time goes into the clever part.
Here's what actually goes wrong:
It dies halfway through. Your server restarts during a deploy. The agent was three steps into a seven-step task. Where is it now? For most setups: gone. It never finishes, and nobody finds out until a customer complains.
It does something twice. Something failed, so a retry kicked in. Now the customer has two refunds. Money left the building twice for one request.
It does something nobody approved. The agent decided a £4,000 refund was appropriate. It was technically following its instructions. No human ever saw it.
Nobody can explain what it did. A customer disputes the outcome. You want to know what the agent saw and why it decided that. If nobody recorded it, the honest answer is "we don't know."
It leaks things it shouldn't have seen. Customer email addresses and card numbers end up in logs and in prompts sent to an AI provider — usually by accident, often discovered late.
It quietly gets worse. Someone tweaks the wording of an instruction. Three unrelated things break. Nothing errors. You find out from users.
Every one of these is an infrastructure problem, not an intelligence problem. A better model does not fix any of them.
What agentFast is
Two kinds of tool are involved in building an agent, and they solve different halves.
Tools like CrewAI and LangGraph decide how your agent thinks — what steps it takes, in what order, which specialist handles what. They're good at that, and agentFast doesn't replace them.
agentFast handles everything that happens around that — the six problems above. It's the difference between an agent that works and an agent you can be responsible for.
You pick one of each. agentFast deliberately doesn't care which thinking tool you chose, and works the same way whichever you pick.
A recipe tells you how to cook a dish. It says nothing about food hygiene, allergy labelling, keeping a temperature log, or what to do when the fridge fails overnight. A restaurant needs both. CrewAI and LangGraph are the recipe. agentFast is everything that makes it a restaurant rather than a kitchen.
What you get, in ordinary words
| What it's called | What it actually means | |---|---| | Durable execution | If the agent is interrupted — crash, restart, deploy — it picks up exactly where it stopped. It doesn't lose the work and it doesn't repeat it. | | Human-in-the-loop | You choose which actions are too important to happen unsupervised. The agent stops and waits for a person to approve those. The pause survives a crash, and an approved action happens exactly once. | | Guardrails | Personal details — emails, card numbers, ID numbers — are stripped out before the AI ever sees them, and before anything is written to a log. Plus protection against people trying to trick the agent through the documents it reads. | | Memory | The agent remembers relevant things about a customer between conversations, without you re-telling it, and without conversations getting slower and more expensive as they get longer. | | Observability | Every step the agent took, what it cost, how long it took — recorded and readable. When someone asks "why did it do that," there's an answer. | | Evals | An automatic quality check that runs before changes go live, and blocks them if the agent got worse. Like tests, but for judgement rather than code. | | Streaming | You watch the agent work in real time instead of staring at a loading spinner — what it's looking up, what it's doing, and the moment it needs you. |
What "durable" means, concretely
This is the claim worth understanding, because it's the one that's hardest to fake.
A customer asks for a refund. The agent checks the policy, looks up the order, decides the refund is justified — and stops, because refunds need a person to say yes.
Now someone deploys new code and the server restarts. The agent's job is halfway done and the computer running it no longer exists.
An hour later a manager clicks approve. The agent continues from that exact point — it doesn't re-read the policy, doesn't re-look-up the order, and issues exactly one refund.
That behaviour is verified automatically every time the code changes, by killing a real process mid-task and checking the outcome. It isn't a recorded demo.
Who this is for
Worth it if your agent takes real actions — money, customer records, external systems — or you work somewhere that will eventually ask you to prove what happened. Regulated industries, anything touching payments, anything where a mistake is expensive.
Probably overkill if you're building something that only answers questions and never acts. If nothing your agent does is hard to undo, you don't need most of this.
Where to go next
If you're technical, the quickstart has it running in about five minutes.
If you're not, the section on the production layer explains each capability in more depth — each of those pages opens with a plain-language summary before the technical detail, so you can read the top of each and stop there.