A colleague of mine built an agent on a free plan in about forty minutes. It read her inbox, pulled out invoice amounts, and dropped them into a spreadsheet. By lunchtime it had run perfectly eleven times. By Thursday it had stopped dead, because she’d used up the monthly allowance and the tool wanted a card on file.
That’s roughly the shape of the free AI agents market right now. There is a lot on offer, much of it genuinely useful, and nearly all of it shaped by limits you don’t notice until you hit them. None of that makes free a bad deal. You just need to know which kind of free you’re signing up for.
Three kinds of free, and they behave very differently
The phrase covers at least three separate things, and mixing them up is where most of the frustration comes from.
Free tiers on paid platforms
Commercial agent builders usually hand you a monthly allowance: a few hundred runs, two or three connected apps, one active workflow. Enough to build something real and small. Not enough to run a process that fires every five minutes. Most of these tiers are honest about the trade, but they change shape every few months, so check the current limits rather than a tutorial written last spring. It’s also worth reading up on how agent platforms hold up against real systems before you commit, because the free tier tells you almost nothing about what happens at scale.
Open-source frameworks you host yourself
LangGraph, CrewAI, AutoGen, Dify, Flowise, the community edition of n8n. The licence costs nothing. The compute doesn’t. You still pay for model calls, and if you run a local model you’re paying in hardware and electricity instead. These are the right choice when you want control over how the agent reasons and where your data lives, which is often the actual reason someone goes hunting for free in the first place.
Hosted agents that are genuinely free
A handful of tools offer small agents at no cost, funded by an upsell or by data. Read the privacy terms carefully on these. A free agent with read access to your email is a very different proposition from one that only sees a public webpage.
The costs that never show up in the pricing table
Every free agent I’ve tested carries the same three hidden bills.
- Tokens. One reasoning loop that checks a calendar, drafts a reply, and verifies its own work can easily consume 15,000 to 40,000 tokens. At small-model prices that’s a fraction of a cent per run. Run it 500 times a day and it’s a line item.
- Your attention. Free tiers rarely include the dull parts: retries, alerting, watching for a tool call that fails silently at 2am. You become the reliability layer, and that’s a job.
- Lock-in. Free tiers are the best customer acquisition tool ever invented. Moving a working agent off one is often a rebuild rather than an export.
There’s a fourth cost that bites later: state. Agents that run unattended need somewhere to keep track of what they’ve already done, and most free setups give you nothing but a short context window. Why agents forget is worth understanding early, because a memory problem looks exactly like a reasoning problem until you dig in.
Where free agents actually earn their keep
Before building anything, work out whether you need an agent at all. Plenty of tasks people hand to an LLM are simple enough for a scheduled script, and the difference between agents and plain automation is usually the difference between a cheap job and an expensive one.
Tasks that tend to justify a real agent on a free tier:
- Triaging a shared inbox into three or four folders, with judgement involved.
- Turning messy meeting notes into a task list with owners attached.
- Checking a supplier’s public page daily and flagging only the changes that matter.
- Drafting a first-pass reply that a human edits before it goes out.
All four have a human check at the end and a bounded scope. That’s not a coincidence. Bounded scope is what keeps a free agent inside its allowance and inside its competence.
Where free quietly stops being free
The limits that catch people are rarely the ones printed on the pricing page.
Free tiers often route you to a smaller, cheaper model than the paid plan does. The agent still works, but it works worse: it misses the edge case, misreads the ambiguous instruction, picks the wrong tool half the time. If you’re debugging behaviour that seems inexplicable, what happens between the instruction and the action is usually where the answer lives.
Then there are seat limits, which matter the moment a second person needs to look at the workflow, and audit logs, which almost never appear on a free plan. If your agent touches customers or money, missing logs are a hard stop regardless of price.
Three tests to run before you trust one
Free is the right time to be sceptical, because the cost of finding a flaw is low.
Break the input. Give the agent the messiest version of the task you have: the email with three questions in it, the invoice with a handwritten total, the document with two conflicting dates. Watch whether it asks for clarification or invents an answer. Inventing is common and it is the failure mode that costs money.
Run it long. Set the same agent on the same task for a week. Anything that has to remember something across sessions will start drifting, repeating work, or losing the thread. This test tells you more about a tool than any feature list.
Pull a tool out from under it. Disconnect the app it depends on and see what happens. A well-built agent fails loudly and stops. A badly built one reports success while doing nothing, which is the most expensive outcome in the entire category.
A build order that keeps the bill near zero
Start with the cheapest model that passes the three tests above. Not the most capable one, the cheapest that survives. Then narrow the job until it fits in a single prompt with two or three tools attached. The agents that work are boringly specific: one job, one output format, one place to put the result.
Keep a log of every run from day one, even if it’s just appending a line to a text file. Without it you can’t tell whether the agent is improving or quietly failing, and you can’t answer the only question that matters when the free allowance runs out, which is whether this thing is worth paying for.
If you’re self-hosting, spend an hour understanding which parts of the agent architecture actually decide whether it works. Most of the failures people blame on the model turn out to live in the plumbing around it.