Everyone is telling you to "build an AI agent." Almost nobody tells you what that actually means, or what separates an agent from a chatbot you could have built two years ago. This guide fixes that. No code, no theory you cannot use, and every tool mentioned is one you can try today.

By the end you will know what an agent is made of, which of the four types you actually need, what it costs to run one, and how to build your first working agent in an afternoon.

What an AI agent actually is

A chatbot answers. An agent acts.

Ask a chatbot "which customers haven't paid?" and it will tell you it has no access to your records. Ask an agent the same question and it checks the payment log, finds the answer, and — if you let it — sends the reminder email itself.

The difference is not intelligence. Both may run on the same model. The difference is that an agent has three things a chatbot does not:

• Tools it can call — an inbox, a database, a calendar, a web scraper
• Memory of what happened before, so it does not start blank every time
• Permission to take an action rather than only describe one

That is the whole idea. Everything below is about giving a model those three things without writing code.

Agent, automation or chatbot?

These three words get used interchangeably and they are not the same thing. The distinction matters because picking the wrong one is the most common reason a project fails.

• Automation follows a fixed path. When a form is submitted, add a row. It never decides anything. It is reliable precisely because it cannot think.
• A chatbot decides what to say but cannot do anything. It has language but no hands.
• An agent decides and does. It reads a messy input, works out what it means, picks an action, and carries it out.

Here is the practical test. If you can write every rule down in advance without any "it depends", you want automation, and you will be happier with it — it is cheaper, faster and it never surprises you. The moment your process contains "it depends on what the email says", you need an agent.

A lot of people build an agent for a job that automation would have handled perfectly. They then spend a month debugging a system that guesses, when a system that follows rules would have worked on day one.

The five parts of every agent

Whatever tool you use, you are always assembling the same five parts. Recognising them makes every no-code builder look familiar, and it makes debugging enormously easier — when something breaks, it broke in one of these five places.

1. The trigger

What starts the agent. A new email arrives. A form is submitted. A schedule fires at 8am. Someone sends a voice note. Without a trigger you have a tool you must open manually, which is not an agent.

Triggers come in three flavours: event-based (something happened), scheduled (every morning at nine), and manual (you press a button). Start with scheduled ones. They are the easiest to test because you can fire them whenever you like.

2. The input

What the agent receives. A message, a PDF, a row of data, a recording. This is usually where no-code agents break — the input arrives as a messy blob and the agent needs it structured.

Be honest about what your real inputs look like. Not the clean sample you made for testing. The scanned invoice that is rotated ninety degrees, the voice note recorded next to a road, the email with the important detail buried in a forwarded thread. Your agent will meet all of those in week one.

3. The reasoning

The model decides what the input means and what should happen. This is the part people obsess over and the part that matters least in practice, because the models are all capable enough. Your instructions matter far more than your model choice.

If you find yourself comparing benchmark scores before you have written your instructions, you are optimising the wrong end of the problem. A clear brief on a mid-tier model beats a vague brief on the best model available, every time.

4. The tools

What the agent can actually touch. Read a sheet, write a record, send a message, scrape a page. An agent with no tools is a very expensive text box.

5. The guardrail

What it may do alone versus what needs your approval. Skipping this is the most common and most expensive mistake. An agent that emails customers without review will eventually email the wrong thing to the wrong person.

Step 1 — Pick one job, and make it small

The agents that fail are the ones asked to "handle customer support." The ones that work are asked to "read incoming invoices and put the totals in a spreadsheet."

A good first agent has three properties: it happens often, it is boring, and a mistake is cheap to fix. Sorting your inbox qualifies. Approving refunds does not.

Write your job as one sentence in this shape: When [trigger], read [input], then [action]. If you cannot fit it in that sentence, it is still too big.

Some examples that pass the test:

• When an invoice email arrives, read the PDF, then add a row to the spreadsheet.
• When a form is submitted, research the company, then write a summary into the CRM.
• Every Monday at 8am, read last week's support tickets, then send me the three most common complaints.

And two that fail it: "manage my calendar" and "help with marketing." Neither has a trigger, a defined input, or a single action. Both will produce a month of frustration.

Step 2 — Choose the type of agent you need

No-code agent tools fall into four groups. Picking the wrong group is why people conclude "agents don't work."

Personal assistant agents

These live in your inbox and calendar and handle the admin around your day. Lindy is the clearest example — it triages email, drafts replies in your own writing voice, schedules meetings and takes notes, then follows up on what you promised. You do not build a workflow; you connect your mailbox and correct it until it sounds like you.

Inbox Zero takes a narrower version of the same job and is open source, so you can read exactly what it does with your mail or self-host it entirely. If handing an AI tool full access to years of email makes you uncomfortable — and it reasonably might — the self-hostable option is worth the extra setup.

Choose this type if your bottleneck is personal admin rather than a business process. The giveaway is that the work only exists in your inbox and nobody else on your team touches it.

Data-gathering agents

These go out and collect something. Bardeen is the most practical entry point: it scrapes any site, researches leads with AI, enriches contacts with verified emails and phone numbers, then drops the result into Sheets, Airtable or Notion. Every plan includes 100 free credits a month, so you can build a real agent before paying anything.

If your input is documents rather than web pages, Parsio is the equivalent — it watches an inbox, pulls structured data out of PDFs and attachments, and pushes it into a spreadsheet or accounting system. Its free plan gives 30 credits a month with every parser engine included.

Choose this type if the work is really "go and find out, then write it down somewhere." This is the single most reliable category of agent, because collecting and structuring data is a task where being roughly right is genuinely useful and being wrong is easy to spot.

Operational agents

These run a process across a team. Lumi is an unusual take: you talk to it. Send a voice note between jobs and it turns your words into tracked tasks, flagged risks and logged commitments, then hands you a morning brief on what is slipping and who went quiet. Every task is pinned to the exact words you said, so you can always see where it came from.

Choose this type if the problem is that things get agreed and then forgotten. The agent's value here is not intelligence, it is memory — it is the only participant in your week that never forgets what was promised.

Product agents

These are agents you build for other people — inside an app you ship. Whacka lets you describe an app in plain language and generates the interface, database, authentication and notifications, then hosts it. If your agent needs its own state and users, Convex is the backend most no-code agent builders graduate into, with a free tier of 1M function calls.

Choose this type if the agent is the product rather than an internal helper. Be aware this is a genuinely different project — you now have users, uptime and support to think about.

Step 3 — Give it tools, not instructions

This is the step people skip, and it is the one that decides whether the agent works.

Telling an agent "check whether the customer paid" does nothing unless it can reach the payment record. Before you write a single instruction, list what the agent must read and what it must write:

• Reads: the inbox, the invoice PDF, the customer sheet
• Writes: a new row, a draft reply, a Slack message

Then connect exactly those and nothing else. An agent with access to everything is not more capable — it is more likely to do something you did not want, and much harder to debug when it does.

There is a security dimension here too, and it is not theoretical. If your agent reads emails from strangers and can also send emails, someone can write an email designed to instruct your agent. The defence is boring and effective: never let the same agent both read untrusted input and take an irreversible action without a human in between.

Step 4 — Write instructions the way you would brief a new hire

The most reliable prompt format for an agent is not clever. It is boring and specific:

• Role: what it is. "You process incoming supplier invoices."
• Input: what it will see. "A PDF attached to an email."
• Steps: what to do, in order, numbered.
• Output: the exact shape you want back. Name the fields.
• Stop conditions: when to give up and ask you.

That last one matters more than the rest combined. "If the total is unclear or the supplier is not in the list, do not guess — flag it for review" prevents the failure mode that destroys trust in agents: confident wrong answers.

Two more habits that make a large difference:

Name your fields explicitly. "Return supplier_name, invoice_date, total_amount and currency" produces something you can use. "Summarise the invoice" produces a paragraph you then have to parse by hand, which defeats the point.

Show one example. A single worked example of input and the exact output you want is worth more than three paragraphs of description. This is the cheapest accuracy improvement available to you.

Step 5 — Run it in shadow mode first

Do not let a new agent act. Let it propose.

For the first week, have it draft the email instead of sending it, or write to a scratch sheet instead of the real one. You are not testing whether it works — you are finding the cases you did not think of. There are always cases you did not think of.

Only widen permissions on the specific actions it has already got right repeatedly. This is how the good implementations are built and it is why they seem to work first time.

What to actually check during shadow week

Keep a simple tally. For every run, note whether the output was correct, wrong, or the agent correctly refused to guess. That third column is the one that matters most — an agent that flags uncertainty instead of inventing an answer is one you can safely expand. An agent with a high "wrong" count and a zero "refused" count has no working stop condition, and no amount of prompt tweaking will fix that until you add one.

Feed it your five worst inputs deliberately. The rotated scan, the email in another language, the invoice with two totals on it. If it handles those, the ordinary cases are already safe.

Step 6 — Decide what it may never do alone

Write this list before you go live, not after something goes wrong. A reasonable default:

• Never send anything to a customer without approval
• Never delete a record — mark it instead
• Never move money, ever
• Never act when confidence is low — escalate

Every tool above supports approval steps. Use them. The cost of a human glancing at a draft is seconds; the cost of an agent emailing your entire client list is not.

What it actually costs to run an agent

This is the question nobody answers honestly, so here are real numbers.

Most no-code agent tools bill in credits rather than a flat fee, and a credit usually maps to one meaningful action — one page scraped, one document parsed, one enrichment. That means your cost scales with volume, not with team size, which is good news for a small business and bad news if your volume is unpredictable.

For a sense of scale: Bardeen includes 100 free credits a month on every plan, and Parsio gives 30 free credits a month with all four parser engines available. Both are enough to build and test a real agent before paying anything. A parsed page on Parsio costs one to three credits depending on which engine handles it, so the cheap template parser is worth using wherever your documents have a fixed layout.

The mistake that costs money is running the most expensive engine on every document because it was the default. Route the predictable inputs to the cheap path and reserve the AI parser for the messy ones. On a few thousand documents a month, that single decision is the difference between a tolerable bill and an unpleasant one.

Budget realistically: a first working agent handling a few hundred items a month usually lands somewhere between free and roughly $30 a month. It is the jump to thousands of items where you need to think about which engine handles what.

A realistic first agent, start to finish

Here is a complete example you can build in an afternoon.

The job: When a supplier invoice arrives by email, extract the supplier, date and total, add it to a spreadsheet, and tell me in Slack if the total is over $1,000.

1. Trigger: new email in a dedicated invoices inbox
2. Input: the attached PDF
3. Extraction: Parsio reads the PDF and returns supplier, date and total as fields
4. Write: a new row in Google Sheets
5. Condition: if total > 1000, post to Slack
6. Guardrail: if any field is missing, flag for review instead of writing a partial row

No code. No model choice. And it removes a task you were doing forty times a month.

A second example: the lead research agent

The invoice agent is the safest first build. This one is the most commonly wanted, so it is worth walking through too.

The job: When someone fills in the contact form, find out who they are before I reply.

1. Trigger: a new form submission
2. Input: name, work email, company
3. Research: Bardeen looks up the company, pulls headcount, industry and recent activity, and enriches the contact
4. Reasoning: the model writes three lines — who they are, what they probably want, and one specific thing worth mentioning
5. Write: that summary lands in your CRM and in Slack
6. Guardrail: if the company cannot be identified with confidence, say so plainly rather than inventing a plausible description

Notice what this agent does not do: it does not reply to the lead. That is deliberate. The research is low-risk and genuinely time-saving; the reply is high-risk and takes you thirty seconds once you have the research. That split — agent does the reading, human does the sending — is the pattern behind most agents that survive past month one.

What actually goes wrong

Four failure modes account for nearly every abandoned agent:

The job was too vague. "Handle my email" is not a job. "Label emails from existing customers as Priority" is.

The input was messier than expected. Real invoices are scanned sideways. Real voice notes have background noise. Test with your worst input, not your cleanest.

There was no stop condition. The agent guessed instead of asking, once, and you stopped trusting it.

Nobody owned it. Agents drift as your process changes. Someone has to notice when it starts being wrong.

There is a fifth that is less discussed: the agent worked and nobody used it. If the output lands somewhere people do not already look, it does not exist. Put results where the work already happens — the inbox, the Slack channel, the sheet the team has open — not in a new dashboard nobody has a habit of opening.

Do you even need an agent?

Worth asking honestly. If the task happens twice a month, a checklist is better. If it needs judgement you cannot write down, an agent will frustrate you. If it is high-stakes and irreversible, keep a human in it.

Agents earn their place on work that is frequent, boring, rule-shaped and cheap to correct. That describes more of most people's week than they expect — which is exactly why starting small and expanding beats trying to automate everything at once.

Common questions

Do I need to know how to code?

No, for everything described here. You will need to be comfortable connecting accounts, mapping fields between tools, and writing clear instructions. That is closer to configuring a spreadsheet than to programming. Code becomes necessary when you want an agent inside your own product with its own users.

Which model should I use?

Whichever your tool defaults to, until you have evidence it is the problem. Model choice is the last thing to tune, not the first. If your agent is failing, it is far more likely to be an unclear instruction, a missing tool connection, or an input you never tested.

How long until it works?

A narrow first agent takes an afternoon to build and about a week of shadow running before you trust it. If you are still fighting it after two weeks, the job was probably too big — cut it in half and try again.

Is my data safe?

It depends entirely on the tool, so check rather than assume. Look for whether your data is used for model training, how long it is retained, and whether self-hosting is offered. Inbox Zero being open source and self-hostable is a real advantage here, because you can inspect the answer rather than trust a marketing page.

Can one agent do several jobs?

It can, and it usually should not. Two narrow agents are easier to debug, easier to trust, and fail independently. One large agent that does five things fails at all five at once and you will not know which part broke.

Where to start today

Pick the one task you did most often last week that you resented doing. Write it as when this, read that, then do this. Pick the matching tool above. Run it in shadow mode for a week.

That is a working AI agent. Everything after it is the same five parts, repeated.