AI agents: build a mini workforce without writing code

Part 7 of the "Build with AI" series

---

So far in this series, we've talked about prompting — giving AI a task and getting a result. One prompt, one response. You ask, it answers.

That's useful. But it's also limited. Because most real work doesn't happen in a single exchange. It happens in sequences. Step A triggers Step B. The result of Step B feeds into Step C. Something external — an email, a form submission, a calendar event — kicks the whole thing off. And at the end, the result goes somewhere: an inbox, a spreadsheet, a Slack channel.

This is where AI agents come in.

An agent is not just an AI that answers questions. It's an AI that acts — that can plan a sequence of steps, use tools, make decisions, and complete a goal with minimal human involvement. It's the difference between a smart assistant who waits for instructions and one who can be handed a goal and trusted to figure out the steps.

And the remarkable thing about 2026: you can build agents without writing a single line of code.

---

What makes something an "agent"

The word "agent" gets thrown around a lot. Let's be precise.

A basic AI interaction looks like this: You → Prompt → AI → Response → You

An agent interaction looks like this: Trigger → Agent → [Plan → Tool → Decision → Tool → Decision...] → Output → Destination

The key differences:

Agents have triggers. They don't wait for you to open a chat window. They activate when something happens — a new email arrives, a form is submitted, a scheduled time occurs, a new row appears in a spreadsheet.

Agents use tools. They can search the web, read files, write to databases, send emails, call APIs, run code. They can reach beyond their context window into the real world.

Agents make decisions. At branching points — if this, then that — they evaluate the situation and choose a path. Not just generating text, but making conditional choices.

Agents have goals, not just tasks. A task is "summarize this document." A goal is "monitor our competitor's pricing page and alert me whenever something changes, with a summary of what changed and why it might matter."

---

Three levels of agents

Not every agent is the same. It helps to think in three levels:

Level 1 — Triggered automation A workflow that fires automatically when something happens, runs a fixed sequence of steps, and delivers a result. No real decision-making — just reliable, automatic execution of a defined process.

Example: Every time a new lead fills out your contact form, automatically look them up on LinkedIn, generate a personalized one-paragraph summary of who they are, and add it to your CRM notes before your team sees the lead.

Tools: n8n or Make.com, with AI for the generation step.

Level 2 — Decision-making agent A workflow that includes conditional logic — where the AI evaluates something and routes to different outcomes based on what it finds.

Example: When a customer support email arrives, the agent reads it, classifies it (billing issue / technical problem / feature request / complaint), checks if the customer is on a premium plan, and routes it accordingly — with different response templates for different combinations.

Tools: n8n with multiple branches, AI classification at decision points.

Level 3 — Goal-directed agent An agent that is given a goal rather than a script — and figures out its own steps to achieve it. It can plan, use tools in sequence, evaluate intermediate results, and adjust its approach.

Example: "Research the top 5 Korean smart city startups in the energy management space, compile their product descriptions, recent funding, and key differentiators, and produce a formatted comparison report."

The agent searches, reads, extracts, organizes, and writes — deciding which sources to use, when it has enough information, and how to structure the output.

Tools: Claude Opus 4.6 or GPT-5.2 with tool access, or platforms like Relevance AI or Claude Code for more complex orchestration.

---

Building your first agent: a real walkthrough

Let's build something real. We'll use n8n — the most powerful free/open-source automation tool available — to build a Level 1 agent.

The goal: Monitor a list of competitor websites. Every Monday morning, check if any of them have updated their pricing page, and if so, send a Slack message with a summary of what changed.

Step 1: The trigger In n8n, create a Schedule node. Set it to run every Monday at 8am. This is your trigger — the agent wakes up automatically without you doing anything.

Step 2: The data source Add an HTTP Request node for each competitor URL you want to monitor. This fetches the current content of their pricing page.

Step 3: The comparison Add a Function node that compares today's content against last week's stored version. If they match — stop. If they don't — continue to the next step.

Step 4: The AI analysis Add an AI node (n8n has native Claude and OpenAI integrations). Pass the old and new content with this prompt:

"Compare these two versions of a competitor pricing page. Identify: (1) what changed, (2) whether prices went up or down, (3) any new plans or features added or removed, (4) your assessment of why they might have made this change. Be specific and concise."

Step 5: The output Add a Slack node. Send the AI's analysis to your #competitive-intel channel, formatted with the competitor name, date, and the summary.

Step 6: Store the new version Save today's content to compare against next week.

Total setup time: 45-60 minutes. Zero code. After that, it runs every Monday automatically — and you only see it when something actually changes.

That's an agent. It wakes up, checks things, decides whether to act, acts intelligently, and delivers the result where you need it.

---

What agents are best for

Not every task benefits from an agent. Here's where they genuinely shine:

Repetitive multi-step processes — anything you do the same way every time, with multiple steps, is a candidate for automation. The agent does it reliably, consistently, at any hour.

Monitoring and alerting — watching for changes, thresholds, or events across sources you can't manually check all the time. Competitor prices, news mentions, lead activity, system statuses.

Data enrichment pipelines — taking raw inputs (a new contact, a new lead, a new piece of content) and automatically enriching them with AI analysis before a human needs to touch them.

First-pass triage — handling the classification and routing of inbound requests (emails, support tickets, form submissions) before human review, so humans only deal with pre-qualified, pre-sorted work.

Report generation — pulling data from multiple sources on a schedule, running AI analysis, and delivering a formatted report without anyone having to compile it manually.

---

Where the field is moving right now

The single-agent use cases above are table stakes. The frontier in 2026 is moving in three directions worth knowing about — even if you're not ready to build them yet.

Agent swarms

A swarm is multiple agents working in parallel, each handling a different part of a larger task, coordinating their outputs toward a shared goal. Instead of one agent doing everything sequentially, you have a team of specialized agents running simultaneously.

Think of it like a project team: one agent researches, another drafts, a third fact-checks, a fourth formats. They hand off to each other, compare results, and the orchestrating agent assembles the final output.

Frameworks like OpenClaw (an open-source multi-agent orchestration framework), LangGraph, and CrewAI are purpose-built for this pattern. CrewAI in particular has become popular for non-developers — you define each agent's role, tools, and goal in plain language, and the framework handles the coordination.

Real example: A market research swarm where Agent 1 searches for industry news, Agent 2 pulls competitor data, Agent 3 analyzes customer reviews, and Agent 4 synthesizes everything into a structured report — all running in parallel, completing in minutes what would take a human analyst hours.

AI employees

This is the concept generating the most conversation right now — and the most legitimate excitement. An AI employee is an agent given the same tools a real employee would have: a computer, a browser, access to company systems, a phone number, a payment method, email, calendar.

Companies like Artisan, Relevance AI, and 11x are already selling "AI SDRs" (Sales Development Representatives) — agents that prospect leads, research them, write personalized outreach, follow up, handle objections, and book meetings. Fully automated, running 24/7.

The more striking development: some companies are now giving agents real payment capabilities through services like Stripe Agent Toolkit, allowing agents to process refunds, issue credits, and handle billing operations autonomously — within defined limits and with audit trails.

Phone-capable agents are also maturing fast. Tools like Bland AI and Vapi let you deploy agents that make and receive real phone calls, handle customer service conversations, qualify leads, and book appointments — indistinguishable from a human caller to most people.

The honest caveat: these are powerful but still early. They work well for narrowly defined, high-volume tasks with clear rules. They break on edge cases, nuance, and novel situations. The "AI employee" framing is slightly ahead of the reality — but the direction is clear and the pace is fast.

Computer-using agents

The newest frontier: agents that can literally use a computer the way a human does. They see the screen, move the mouse, click buttons, fill forms, navigate websites — without needing an API or integration.

Anthropic's Computer Use, OpenAI's Operator, and Google's Project Mariner are all exploring this. The implication is significant: any task a human can do on a computer becomes automatable, even if there's no API for it. Legacy software, government portals, any web interface — an agent can operate it.

This is still early and unreliable for production use. But it closes the last gap between "what an agent can access" and "what a human can access on a computer."

---

Memory and communication: how agents think across time

Once you understand agents, the natural next question is: do they remember anything? And if there are multiple agents working together, how do they talk to each other?

These are the right questions — and the answers are more nuanced than most introductions cover.

The four types of agent memory

In-context memory (short-term) This is the agent's active working memory — everything in its current context window. What it's seen, done, and said in the current session. Fast, immediately accessible, and completely gone when the session ends. Think of it like RAM. Powerful while running. Wiped when you turn it off.

The practical limit: even a 1M token context window fills up during long multi-step workflows. When it fills, older content gets dropped or summarized. Agents that don't manage this well start "forgetting" earlier steps.

External memory (long-term) Agents can read from and write to external storage — databases, files, spreadsheets, or specialized memory stores. This is persistent memory that survives between sessions. When an agent needs to remember something across runs — a customer's history, a previous decision, a fact from last week — it writes to external storage and retrieves it next time.

Tools like Mem0 and Zep are built specifically for this, storing memories as searchable embeddings so agents retrieve relevant context rather than loading everything. This is what makes a "personal assistant" agent feel like it actually knows you over time.

Procedural memory (baked-in skills) This is the model's training — what it inherently knows how to do. Write code, summarize text, analyze data. You can't add to it at runtime; it's fixed per model version. But you can extend it by giving the agent tools and instructions that expand what it can act on.

Episodic memory (action history) A log of what the agent has done — past tool calls, past outputs, past decisions. Stored externally and retrieved at the start of a new session so the agent understands "what happened last time." Critical for avoiding duplicate actions and infinite loops.

How agents talk to each other

In a swarm or multi-agent system, agents need to coordinate. Three main patterns:

Shared memory (blackboard pattern) All agents read from and write to a shared data store. Agent 1 writes research findings to the blackboard. Agent 2 reads those and writes a draft. Agent 3 reads the draft and edits it. No direct agent-to-agent messaging — they coordinate through shared state. Simple, reliable, easy to debug. The preferred pattern for most production systems.

Direct messaging (message passing) Agents send structured messages directly to each other — like a Slack DM between teammates. Agent 1 sends its output to Agent 2 with explicit instructions for what to do with it. Frameworks like CrewAI and AutoGen use this model. Agents have defined roles and pass work through a message queue.

Orchestrator pattern A central "manager" agent controls the workflow. It assigns tasks to worker agents, collects their outputs, evaluates quality, and decides next steps — including sending work back for revision if it falls short. This mirrors how a good human manager runs a team. The orchestrator has the full picture; workers handle specialized subtasks. Most enterprise-grade agent systems use some form of this.

The memory problem that actually bites you

Here's what most people don't realize until they've built something: agents don't automatically know what they've already done.

In a multi-step workflow, if the agent doesn't explicitly record its progress, a failure halfway through means starting over from scratch. If it runs again next week, it has no idea it already processed something — and it will process it again.

This produces a category of bugs unique to agents:

• Duplicate actions — agent sends the same email twice because it never recorded sending it the first time
• Lost context — agent makes a decision without knowing a relevant prior decision from earlier in the workflow
• Infinite loops — agent keeps retrying something that failed, without any record that it already failed

The fix is explicit state management — writing checkpoints to external storage at every meaningful step, so the agent can always answer: what have I done, what do I still need to do, what failed? Every serious agent framework has a pattern for this. It's unglamorous. It's also what separates a reliable production agent from a demo that breaks in the real world.

---

The common mistakes

Automating a broken process An agent will faithfully execute a bad process at ten times the speed. Before you automate, make sure the underlying process is actually correct. Automation amplifies — both good and bad.

No human checkpoint on consequential outputs For anything that reaches a customer, a partner, or the outside world — always build in a human review step before sending. An agent that drafts is powerful. An agent that sends without review is a liability.

Over-engineering the first version Start with Level 1. A simple triggered automation that saves two hours a week is worth more than a complex Level 3 agent that takes weeks to build and breaks often. Get the simple version working, learn from it, then add complexity.

Not planning for failures External services go down. APIs change. Pages 404. Build error handling into every agent — what should happen when a step fails? At minimum, send yourself an alert so you know something broke.

---

Agents and MCP: the connective tissue

Underpinning all of the above — from basic Level 1 automations to full AI employee setups — is MCP (Model Context Protocol), which we first discussed in Post 2.

MCP is what lets agents connect to external services through standardized interfaces rather than fragile custom integrations. Your agent can natively access Google Drive, Gmail, Slack, GitHub, your CRM, your accounting tool — through a growing library of standardized connectors that any agent framework can use.

This is why agent swarms are becoming practical: when every agent speaks the same connection protocol, coordinating them across different services becomes dramatically simpler. And it's why the AI employee concept is accelerating — once an agent can connect to payment systems, phone APIs, and browser interfaces through MCP, the operational capabilities expand rapidly.

When you're evaluating any agent tool or platform, ask whether it supports MCP. Those that do will compound in capability over time as the connector library grows. Those that don't will eventually hit a ceiling.

---

Your first agent challenge

Don't start with something ambitious. Start with something annoying.

Think about something you do repeatedly that follows the same steps every time. Something that takes 15-30 minutes, happens at least weekly, and feels like it shouldn't require a human. A report you compile. An update you send. A check you run. A summary you write.

That's your first agent candidate.

Map out the steps on paper first. What triggers it? What are the sequential steps? Where does a human decision currently happen — and could a rule replace that decision? What's the output and where does it go?

Once you have that map, open n8n or Make.com and build it. Start with Level 1. Get it running. Then watch it run on its own for a month — and notice what you'd want to add.

---

Key takeaways

An agent is AI that acts, not just answers — triggers, tools, decisions, goals are what separate an agent from a chatbot. Start at Level 1: most of the value lives in simple triggered automations, and complexity comes later when you understand the problem deeply. n8n and Make.com let you build agents without code; most non-developers can get a working agent running in an afternoon. Automate the draft, the classification, the routing — but keep humans in the loop for anything that goes to the outside world. The best first agent is the one that eliminates a small, repeatable frustration. And without explicit checkpoints written to external storage, agents duplicate work, lose context, and loop on failures — state management is what separates a reliable agent from a flaky one.

---

Want the full framework?

This post covers the foundations of agents. The AI Development Guide by Jaehee Song goes deeper — into multi-agent architectures, how to design agent workflows for specific business domains, and how to combine agents with the prompting and data foundations we've covered in earlier posts.

📱 Apple Books ▶️ Google Play Books 🌐 All Platforms (Books2Read)

---

Next in the series: "Vibe Coding — Build a Real App Using Plain English" — how to go from idea to a working, deployed application without writing a line of code yourself.