AI agents ·
the complete guide
by a non-dev.

What is an
AI agent?

In practice, an AI agent starts from an intention you give it in plain English (or French, or any language an LLM understands). Instead of just replying with text like a classic chatbot, it decides to call tools: read a file, query a database, send an email, run a web search. It observes the result, thinks, and starts over if needed. The loop stops when the goal is reached, or when a human takes back the wheel.

Agent vs chatbot · the core difference

A chatbot answers. An agent acts. ChatGPT in classic chat mode is a chatbot: you ask a question, it generates text. An AI agent is different: you tell it "send a brief to my last 10 leads" and it actually reads your CRM, opens Gmail, writes 10 personalized emails, and asks you to approve before sending them. That ability to take real-world actions is what changes everything.

This distinction is recent. In 2023, we mostly talked about "AI assistants" that suggested text. In 2024, the first real agent frameworks shipped (LangChain, AutoGen). In 2025, LLM reasoning crossed a threshold that made agents reliable on complex tasks. 2026 is the year AI agents became usable in everyday life, even for non-developers.

Why 2026 is the year of agents

Three things changed at the same time. First, the models got better at reasoning: Claude Sonnet 4.x, GPT-5 and Gemini 2 reason across several steps without losing the thread. Second, the MCP standard took off: since late 2024, any agent can plug into Sanity, Stripe, Telegram or any service through the Model Context Protocol. Third, no-code agents emerged: Lindy, Crew AI Studio, Zapier AI Actions let you put together an agent in an hour, no code required.

The result: what took a team of devs and two months of work in 2023 gets done in an afternoon in 2026. That's why I wrote this page: the barrier to entry has collapsed, and a lot of people don't know it yet.

The 3 levels to
build an agent.

Before asking which tool to choose, you need to know which level you want to play at. I've tested all three. Each has its own logic, its limits, its audience. Here's my way of reading it.

Level 1 · No-code (the on-ramp)

No-code is the option to start with. You don't write a single line of code. You drag and drop blocks in a visual interface. The agent is built as an assembly of bricks. My four favorite tools at this level:

• Lindy · mainly an email agent, but also calendar, research, automations. Very clean, free plan, paid at $49 a month if you're serious.
• Zapier AI Actions · the no-code giant shipped an AI layer. You connect your usual 7,000 apps with an agent on top. Handy if you already live in Zapier.
• Crew AI Studio · the no-code version of CrewAI, the open-source framework. You build teams of agents that collaborate. More visual and more complete than Lindy for multi-agent workflows.
• n8n + AI · n8n is an open-source automation tool you can self-host for free. Its AI layer is solid, and you keep control of your data.

My advice: if you're starting out, begin with Lindy or Crew AI Studio. You'll have a working agent in an hour. It's the best way to understand the logic before leveling up.

Level 2 · Low-code (the sweet spot)

Low-code is my favorite level. You write a bit of configuration in YAML, JSON or markdown, but the tool does the heavy technical lifting. You keep control, without the effort of a full-code project. My three options at this level:

• Claude Code + skills + MCP · my daily stack. Claude Code is Anthropic's terminal agent, skills are folders of instructions that trigger automatically, and MCP lets you plug in any external service. The complete guide is here.
• OpenAI Custom GPTs · you build an agent in a few minutes through a guided interface inside ChatGPT. Limited to OpenAI tools (search, code interpreter, DALL-E), but very accessible.
• Anthropic Skills (in Claude Desktop) · same logic as Claude Code skills but without a terminal. Mac and Windows. The lowest barrier to entry of them all.

My advice: if you do writing, marketing, sales, or any knowledge work, Claude Code will give you 10× more leverage than a no-code tool. The learning curve is a few days, not a few months.

Level 3 · Full code (for real projects)

Full code is when you want to build an agent that goes to production with hard constraints: performance, optimized cost, deep integration into an existing system, a technical team behind it. The reference frameworks in 2026:

• LangGraph · the evolution of LangChain, the most widely used Python framework for orchestrating complex agents. State graphs, persistence, native human in the loop.
• Anthropic Agent SDK · Anthropic's official SDK for Python and TypeScript. Simpler than LangGraph, more opinionated. Ideal if you're building everything around Claude.
• AutoGen (Microsoft) · a conversational multi-agent framework, strong for setups where several agents collaborate.
• OpenAI Agents SDK · the equivalent on the OpenAI side. Public release in late 2025, maturing fast.

My advice: only go full code when low-code no longer cuts it. For 90% of personal and even SMB use cases, Claude Code covers the need. Full code is useful when you want to self-host, scale to thousands of users, or have fine-grained control over token cost.

Comparison table

Popular AI agent
workflows in 2026.

Here are the six agent workflows I see working best in 2026, both in my own use and from what I track. For each, I give the pitch, the tool I recommend, and a link to a deeper tutorial when one exists.

The cost of an AI agent
in 2026.

The cost of an agent depends on three things: the tool you choose (no-code, low-code, full code), the AI model behind it (Claude, GPT, Gemini, Llama), and how intensively you use it. Here are the real ranges I see around me in May 2026.

Indicative pricing table

The hidden costs people forget

What shows up on the invoice is never the real cost of an agent. Here are the hidden costs I see come up all the time.

• Maintenance · an agent that works today can break tomorrow if a third-party tool's API changes. Budget 2-3 hours a month of maintenance for an agent in production.
• Debugging · when an agent goes haywire, you have to figure out why. Tracing tools (LangSmith, Helicone) cost an extra $20-50 a month.
• Monitoring · if the agent runs unsupervised, you can wake up one morning to a €500 API bill because it looped on an error all night. Always set a daily cost cap.
• Learning · the time you spend learning the tool and iterating on your prompts. The first week, budget 10-15 hours for a clean setup.

When a paid agent is worth it

My simple rule: an agent is worth its price when it saves you at least 3 hours a month. At €50 a month, with 3 hours saved at €25 an hour (your baseline personal time), you're already in the black. For a sales or contract agent that saves you 10 hours a month, the ROI is massive.

What's not worth it: paying for an agent you only use to show off. No need to subscribe to a $99 tool just to go "wow, I have an AI agent." Start with Claude Pro at $20 or a free n8n, and upgrade when the real need shows up.

The architecture of an agent ·
the technical building blocks.

Whether you're in no-code, low-code or full code, an AI agent is always made of the same building blocks. Understanding these blocks helps you choose your tools better and debug more easily when something breaks. Here are the six fundamental blocks.

Block 1 · The LLM (the brain)

This is the language model that reasons, decides which tool to call, interprets the results. In 2026, the leaders are Claude (Anthropic), GPT (OpenAI), Gemini (Google) and Llama (Meta, open-source). The choice of LLM affects reasoning quality, speed and cost. For a personal agent, Claude Sonnet 4.x or GPT-5 mini are solid choices. Read the LLM entry.

Block 2 · Tools (function calling)

Tools are what the agent can call. Read a file, send an email, run a web search, query an API. Technically, this is what's called function calling: you describe a function to the agent (name, parameters, what it does), and it decides when to call it. Without tools, the agent is just a chatbot. Read the Tool use entry.

Block 3 · MCP (Model Context Protocol)

MCP is the open standard launched by Anthropic in late 2024 that lets any agent plug into any external service. Instead of coding a custom integration for each tool (Sanity, Stripe, Telegram, GitHub), you install an MCP server and the agent can use it as if it had been built for it. This is what made the agent ecosystem explode in 2025-2026. Read the MCP entry.

Block 4 · Memory

Without memory, an agent forgets everything between runs. Memory breaks down into two layers: short term (the current conversation context, limited to 200K-1M tokens depending on the model) and long term (often implemented via embeddings stored in a vector database like Pinecone, Supabase pgvector or Weaviate). Long-term memory lets the agent remember your preferences, your past interactions, your documents.

Block 5 · The execution loop (agentic loop)

This is the heart of what separates an agent from a chatbot. The typical loop: the agent thinks, picks a tool, runs it, observes the result, and starts over if the goal isn't reached. This loop can run once or 100 times depending on the complexity of the task. It's these iterations that give an agent its autonomy. Read the Agentic workflow entry.

Block 6 · Guardrails and human in the loop

Guardrails are the rules that stop the agent from messing up: no touching certain files, no exceeding a budget, no sending an email without approval. Human in the loop means asking a human to approve sensitive actions before they're carried out. These two blocks are essential the moment the agent touches real data. Without them, it's only a matter of time before it slips up.

A simplified diagram of the architecture

Here's how these blocks fit together in practice:

• You give an intention to the agent in plain English.
• The LLM breaks it down into sub-tasks.
• For each sub-task, the agent picks a tool (read a file, run a search, call an API).
• The tool runs via MCP or native function calling.
• The agent observes the result, saves it to memory if relevant, and decides the next step.
• On sensitive actions, the agent hands off to the human for approval.
• The loop continues until the goal is reached, the budget is spent or it's explicitly stopped.

It's this architecture that lets an agent deliver a client-qualification brief in 3 minutes, or generate a complete newsletter in 10 minutes. It's not magic, it's just orchestration.

To go further on context engineering (the art of giving the right context at the right moment to an agent), I'd suggest reading the dedicated entry or following me through the newsletter — it's a topic that deserves several articles all on its own.

Common mistakes when
you build your first agent.

I've made every one of these mistakes at least once. If you're starting out, here are the six most frequent pitfalls and how to avoid them. This section will save you weeks.

Mistake 1 · Over-trusting the agent

The first time an agent delivers something impressive, you think "great, I can let it run on its own." Bad idea. An agent that works 9 times out of 10 will let you down on the 10th, on the most important action. Rule: if a mistake by the agent could cost you dearly (email sent to the wrong client, data deleted), keep a human in the loop.

Mistake 2 · No logs

When the agent goes haywire, you want to understand why. Without detailed logs (which prompt was sent, which tool was called, which result came back), you're flying blind. Set up minimal logging from day 1. For Claude Code, it's native. For other tools, wire up LangSmith, Helicone or a basic log file.

Mistake 3 · No timeout or budget cap

An agent can loop indefinitely on an error, burning tokens with every iteration. I've seen real cases where an agent running on its own generated €200 of tokens in one night because it was stuck in an error loop. Always set a max number of iterations (say 20) and a daily budget cap.

Mistake 4 · Plaintext credentials

Connecting an agent to your Gmail requires OAuth credentials. If you paste those credentials into a prompt or an unprotected file, it's game over the moment they leak. Always use environment variables (.env) and add them to .gitignore. For agents that touch sensitive data, I use a secrets vault (1Password CLI, Doppler, Vercel env).

Mistake 5 · A prompt that's too vague

"Sort my emails" is a prompt that will produce a mediocre result. "Sort my emails into 4 categories: Urgent, reply today; Reply this week; Newsletters to archive; Spam to delete. For each email, give your confidence as a %" will produce a result 10× better. The more precise and structured the prompt, the better the agent. That's the whole art of context engineering.

Mistake 6 · Trying to do everything at once

The first agent you build should do ONE thing, well. Not sort emails AND plan your day AND generate summaries. Start simple, add capabilities one by one, test at every step. An agent that does one thing well beats an agent that tries to do everything badly. That's been true of software engineering for 50 years, and it's just as true for agents.

Mistake 7 · Ignoring maintenance cost

You build an agent in an hour, it works, you move on. Three months later, the Gmail API changes an endpoint, the agent fails silently, you miss important emails for two weeks before you notice. Set up a simple alert (an email to yourself, a Telegram notification) that warns you if the agent stops running as expected.

Essential articles
on AI agents.

On Jerwis, I've published several longer articles on AI agents. Each one rounds out an angle of this guide. Here's the order I'd recommend reading them in, depending on where you're starting from.

AI agent
glossary.

The 12 terms you'll run into constantly when you build AI agents. A short definition here, a link to the detailed entry to dig deeper.

• Agent An LLM with tools, an execution loop and a goal. It's the basic unit. See the glossary →
• Subagent An agent that another agent launches to delegate a sub-task, often in parallel. Detailed entry →
• Agentic workflow A sequence of actions orchestrated by one or more agents to reach a goal. Detailed entry →
• Tool use An LLM's ability to call external functions (read a file, run a search, etc.). Detailed entry →
• MCP Model Context Protocol, Anthropic's open standard for plugging an agent into any external service. Detailed entry →
• Skill agent A folder of instructions that triggers automatically when the agent recognizes the domain of your request. Detailed entry →
• Human in the loop Having a human approve the agent's sensitive actions before execution. Detailed entry →
• Guardrail A rule that stops the agent from taking certain risky actions. Detailed entry →
• Context engineering The art of giving the right context at the right moment to an agent, so it makes the best decisions. Detailed entry →
• Agentic RAG An agent that decides for itself when to search its knowledge base, rather than searching every time. Detailed entry →
• Embedding A vector representation of a text that lets an agent compare documents by meaning, not by words. Detailed entry →
• Hallucination When an LLM makes up false info and presents it as true. The worst enemy of reliable agents. Detailed entry →

The exhaustive
AI agent FAQ.

The 15 questions I get most often in May 2026 about AI agents. Short answers, based on my direct experience.

Resources
and useful links.

External resources (the essentials)

Internal resources (my content on Jerwis)