AI Agents - What They Are, How They Work, and When to Deploy Them

An AI agent is not a chatbot - it is an autonomous system that receives a goal and independently plans the steps needed to achieve it. In a marketing agency, an agent can prepare a full client brief before a meeting without any human involvement: it searches for company data, checks CRM history, pulls the last proposal and delivers a finished document. That distinction is what unlocks several hours per day that were previously consumed by coordination overhead.

ChatGPT answers questions. An AI agent asks them itself, searches the web, makes decisions, and executes tasks - without your involvement. I explain the architecture, agent types, and when it actually makes sense to invest.

Mark runs a marketing agency - eight people, a dozen clients, a permanent shortage of time. He spends every morning on email: qualifying leads, responding to pricing enquiries, routing requests to the right specialists. In the afternoons he writes proposal briefs, researches potential clients before meetings, and updates the CRM. By 6pm he has not touched any of the actual project work.

When I asked him whether he had heard of AI agents, he replied: "Same thing as ChatGPT, right?" That is a fair question. And the answer is exactly where the important distinction begins.

What an AI Agent Is - and What It Is Not

ChatGPT today is more than a language model: it has memory, searches the web, and in agent mode it can click through websites on its own. But it still works when a person asks it to, in their window and on their account. It doesn't live inside your processes, doesn't react on its own to a new email in the sales inbox and has no permissions in your CRM.

An AI agent is something different. It receives a goal - for example "prepare me a client brief before tomorrow's meeting" - and independently plans what steps to take to achieve it. It searches for information about the company, checks the CRM history, pulls the latest proposal from the drive, combines the data, and delivers a finished document. Without your involvement at every step.

The difference between a chatbot, automation, and an AI agent is fundamental. To see it clearly:

A chatbot responds. Automation executes a fixed flow. An agent plans and decides.

That last point is critical. Zapier can send an email when a form is submitted. An agent can read that email, understand what the client wants, check whether they match the ICP criteria, decide whether to respond immediately or escalate to a human, generate a personalised reply, and log everything in the CRM - all without a single if-else written by a developer.

How an AI Agent Works - Architecture

An AI agent is not a single model. It is a system built from four elements working together.

LLM (Large Language Model) is the brain of the agent. GPT-6.1 Sol, Claude Sonnet 5.5, Gemini 3.1 Pro - the model that understands the instruction, plans the steps, and interprets the results. On its own it is useless without the other components.

Tools are the hands of the agent. A set of functions the LLM can call: web search, database, email API, Python script, spreadsheet. The agent does not guess - it uses a tool, gets the result, analyses it, and decides what to do next.

Memory operates at two levels. Short-term is the context of the current session - the full history of actions and observations the agent has performed so far. Long-term is an external vector database (e.g. Pinecone, Chroma) - this is where the agent stores and retrieves information between sessions. Without long-term memory an agent "forgets" between tasks.

Planner / Orchestrator is the decision logic. It decides when to call a tool, when to ask the user for clarification, when to consider the task complete. The most commonly used pattern is ReAct (Reason + Act) - I think, I act, I observe, I think again.

The agent loop works as follows: the agent receives a goal, selects a tool, executes an action, observes the result, and decides whether to continue or whether the task is done. This cycle can run a dozen times before the agent delivers the final output.

Here is what a simplified implementation of this loop looks like:

# Simplified ReAct loop - Reason + Actwhile not done:    thought = llm.reason(current_context, available_tools)    action = llm.choose_tool(available_tools, thought)    observation = tools.execute(action.name, action.params)    current_context.append({"thought": thought, "action": action, "result": observation})    done = llm.check_goal_reached(current_context, original_goal)return llm.summarize(current_context)

The loop continues until the agent assesses the goal is achieved or encounters a situation requiring human intervention. In practice you add iteration limits and a human-in-the-loop checkpoint as a safety net against infinite loops.

Types of Agents

There is no single "AI agent". There are several architectures, each with different trade-offs between speed, quality, and cost.

ReAct is the most commonly used - simple, predictable, easy to debug. The right starting point.

Plan & Execute creates a full task plan before executing. Better for complex research tasks where the end result is known - for example "write a market research report on five competitors". The agent plans all steps first, then executes them.

Self-reflection is an agent that evaluates its own work after completing a task and improves it before delivery. More expensive in tokens, but significantly better on tasks requiring precision - code generation, legal analysis, proposal writing.

Multi-agent is an architecture where several specialised agents collaborate like a team. One collects data, another analyses it, a third writes the report. Works well with complex processes that can be divided into independent specialisations. The CrewAI and AutoGen frameworks implement this pattern.

Frameworks and Tools

Building an agent from scratch makes no sense. There are several mature frameworks that differ in philosophy and target audience.

From my own experience: LangGraph gives the greatest control, but requires Python knowledge and time to learn. State graphs, transition conditions, built-in checkpoints - this is a tool for someone who understands software architecture, not just prompting.

n8n with AI nodes is the fastest route to a working agent in a company without a tech team. I have deployed several such solutions - visual flow editor, built-in connectors for CRM, email, spreadsheets - everything ready. Limitations appear with more complex decision logic.

CrewAI is my favourite framework for building production agents - readable syntax, good documentation, proven multi-agent patterns. I choose the tool for the specific problem, not the other way around.

Flowise is a good choice for a prototype - drag components, connect with arrows, get a working agent in an hour. Not suitable for production with serious reliability requirements, but excellent for a Proof of Concept.

Model vendor SDKs are the youngest and fastest-growing category. The OpenAI Agents SDK, Claude Agent SDK and Google ADK provide a ready agent loop, tool calling and MCP server support without a framework layer in between. Less abstraction means more predictable behaviour and easier debugging, but also a stronger tie to one vendor - which is why I keep the model name and tool definitions in configuration. Microsoft, meanwhile, merged AutoGen and Semantic Kernel into the Microsoft Agent Framework (version 1.0 in April 2026), so new projects in the Microsoft ecosystem are worth starting there.

Concrete Use Cases - Where an Agent Delivers Real Value

Theory covered. Let us move to numbers, because that is the only measure that matters in a conversation with a business owner.

A category of its own is work on search data - technical audits, keyword clustering, meta data and reports; I laid out six such workflows in the post on SEO automation with AI agents.

The best example I deployed recently is a B2B lead qualification agent - qualification in 8 minutes instead of 45 and payback after 18 days. I break it down step by step in the case study below.

A second example: brand mention monitoring agent. Every morning at 7am the agent scans Reddit, Twitter/X, Google News, and industry forums - identifies mentions of the client and competitors, assesses sentiment, flags reputation crises, and generates a PDF report with a summary and recommendations. Previously someone did this manually for two hours every day.

When an Agent Is Overkill

AI agents are not the answer to every problem. There are several situations where a simpler solution is better, cheaper, and more reliable.

When I do not deploy an agent: - Contact form → save to CRM. That is a webhook, not an agent. Zapier for 20 dollars per month. - Daily reports from the same sources with the same fixed structure. Cron job and Python script. - Notifications after an event. n8n basic flow at zero cost per month. - Processes with zero exceptions and a constant input-output schema.

When an agent makes sense: - The task requires reasoning, not just passing data - Input data is variable and unpredictable - each case is slightly different - The output must be context-adapted, not template-based - There are exceptions that need to be handled differently from standard cases

The simple test I use when qualifying a project: would I give this task to an intern with internet access and a CRM, and would they manage after a 30-minute briefing? If yes - an agent can do it. If it requires an expert with years of experience and deep business intuition - the agent will not cope or will be unreliable and expensive to fix.

How Much Does It Cost

The question that always comes up at this point in the conversation. And rightly so.

To see this in numbers: if a sales email agent saves 20 hours per week and the hourly rate is 30 GBP - that is 600 GBP per week, 2,400 GBP per month. A no-code agent deployed for 500 GBP pays back within 15 days. Monthly API: around 50 GBP.

This is not a long-horizon investment. It is price arbitrage - pay once, save every month.

API costs depend on the model and token count. A cheap model (e.g. GPT-6 Luna at $0.10 per million input tokens) costs 20 times less than a mid-tier model (GPT-6.1 Sol at $2) and is perfectly adequate for simple steps. In the agents I deploy, I always match the model to the step: classifying an email as "urgent/not urgent" doesn't need a strong model, generating a PLN 15,000 proposal does.

An important note on API costs: an agent executing 10 steps to handle one lead can consume 3,000-8,000 input tokens and 1,000-2,000 output tokens. With GPT-6.1 Sol that's about 2-4 cents, and at 50 leads a week, $1-2 a week. Watch out for loops: an agent that gets stuck repeating steps can burn a hundred times more, which is why a step limit and a per-task budget are mandatory.

The Agent Card - One Page Before the First Line of Code

Before I build an agent, I fill in one page with the client. If any field can't be filled in, it's a sign the process isn't ready for an agent yet:

The "what the agent may not do" field adds the most value - it forces a conversation about permissions before anyone gives the agent full CRM access. I cover how to limit permissions and what to log in the post on AI agent security.

How to Start - 6 Steps

I do not start with technology. I start with the process.

1. 1.Identify the most expensive repetitive task - not "many tasks", one specific one. The one that costs you or your team the most time every week. Write it down.

1. 2.Describe it step by step - from start to finish, as if briefing a new employee. What is the input? What decisions are made? What is the output? Where are the exceptions? This description becomes the agent blueprint.

1. 3.Check data availability - the agent needs access to the same sources as the human doing the same task. Does the CRM have an API? Are emails accessible via IMAP or Gmail API? Do you have historical examples of good and bad outputs?

1. 4.Choose the framework - for a company without a developer: n8n or Make with AI nodes. For a company with Python access: LangGraph or CrewAI. Do not over-engineer at the start. A simpler tool that works beats an advanced one sitting broken on a server.

1. 5.Build an MVA - Minimum Viable Agent - one goal, three tools maximum, human oversight after each step. Test the agent on 20 sample cases. Then and only then extend with more tools and less human oversight.

1. 6.Measure the result - time before vs. after deployment, output quality (does the sales rep use the draft or rewrite it from scratch?), cost of errors. Without measurement you do not know whether the agent is better than a human.

The most common mistake I see: companies want to immediately build a multi-agent system to automate an entire marketing or sales department. This almost always fails - too many variables, too few tests, too high expectations. One agent, one task, one month of production operation - then the next.

What Deployment Looks Like in Practice - Case Study

Here is a concrete project: a lead qualification agent for an SEM agency, a 3-person sales team, around 30 leads per week.

Before deployment: - Each lead required 40-50 minutes of work: checking the client's website, LinkedIn, advertising spend history, budget estimate - Sales reps spent half their time on leads that never passed qualification anyway - No consistent scoring system - each rep had their own intuitive criteria

Agent architecture: 1. Typeform webhook activates n8n 2. n8n calls a LangChain agent with a cheap model (GPT-4o mini at the time of the rollout) 3. The agent has access to 4 tools: Playwright (website scraping), LinkedIn API (company data), SerpAPI (organic visibility), RAG memory with client ICP 4. The agent generates a client card: industry, size, estimated budget, ICP fit 0-100, justification and recommendation 5. The card goes to HubSpot as a deal with the right fields populated 6. Slack alert to the appropriate sales rep with priority level

After 30 days: - Qualification time: 8 minutes instead of 45 minutes - Leads rejected below score 40: 35% of all leads - reps stopped wasting time on them - Time to first contact with premium lead (score > 70): from 6 hours to 45 minutes - ROI: agent cost 800 GBP to build + 35 GBP/month in API. With 3 reps each saving 6 hours per week at 35 GBP/hour - payback in 18 days.

Key observation: during the first two weeks, reps reviewed every client card and gave feedback ("this should be 80, not 60, because of X"). This feedback went into the prompt as additional examples. After four weeks, scoring accuracy reached a level that satisfied the whole team.

Common Mistakes When Deploying Agents

Over the last two years I have deployed a dozen agents for various companies. The same mistakes come up again and again.

Mistake 1: Tools that are too generic. An agent with access to "the internet" and "all CRM data" is weaker than an agent with access to three specific, well-defined tools. Precision beats breadth every time.

Mistake 2: No positive and negative examples. An LLM needs patterns. "A good lead is a company with 50+ employees and a budget above 3,000 GBP per month" is a better instruction than "assess fit against our ICP". Concrete examples are worth more than general definitions.

Mistake 3: No production monitoring. An agent operating autonomously without logs is a time bomb. Every tool call, every decision, and every result should be logged. Not to read constantly, but to have the ability to debug when something goes wrong.

Mistake 4: An overambitious MVP. The first agent should do one thing well - not three things adequately. Expansion comes with time and production experience.

Mistake 5: The same autonomy for every action. An agent that tags emails on its own doesn't need to send bank transfers on its own. The level of oversight is set separately for each action, based on the cost of a mistake and whether it can be undone - I cover this in the post on human-in-the-loop in practice.

FAQ

---

I design and deploy systems like this through my AI agents for business service, part of AI process automation. If you have a specific process in mind and want to check whether an agent is the right choice - get in touch. We will start with a 30-minute conversation about what is eating your time, and assess together whether an agent is the right tool or whether a simpler flow will do.