From Single Agents to Orchestrated Teams — plus your always-on Hermes assistant
Dr. Aki Wijesundara
Instructor
Eight parts — agents in n8n, then Hermes as your front door
What is n8n and why it matters for AI systems
The building blocks you need to understand
Single agent with tools (AI calculator)
Why one agent isn't enough
Orchestrator pattern with lead enrichment
Always-on assistant on WhatsApp / Telegram
Packaged abilities and recurring jobs
General submission + stretch goals
Open-source workflow automation built on a directed graph architecture
AI agents, memory, tools, and output parsers are first-class citizens — not plugins
Your data, your infra, your models. Critical for production AI where data governance matters
Every node run is logged with full input/output. See exactly what happened and why
400+ integrations. Supports JavaScript and Python inside nodes. Free tier on n8n cloud, or self-host for free forever.
Every n8n workflow is composed of nodes in four categories
Entry points — a workflow does nothing until a trigger fires.
Perform operations on external systems. The "do" nodes.
Control flow and reshape data. Your control flow primitives.
The layer we'll spend most of today on.
AI Agent Tool — the multi-agent primitive. Makes one agent available as a tool to another agent.
The agent follows a ReAct (Reasoning + Acting) loop
User's message or data from previous node
LLM looks at input, system prompt, and available tools
Agent calls a tool (calculator, web search, API, sub-agent)
Tool returns a result. Agent reads it.
Enough info? Return output. Otherwise, call another tool.
This is not a simple input → output pipeline. It's an autonomous loop where the LLM decides the control flow at runtime.
Default limit: The loop runs up to N iterations (configurable, default 10). If the agent can't resolve in N steps, it returns whatever it has.
A chat-based AI agent that does math using a calculator tool
// User asks:
"What is 4,782 divided by 17?"
// Agent reasons:
"I need to compute this"
→ calculator("4782 / 17")
→ 281.29...
→ "4,782 / 17 = 281.29"Without the calculator tool, the LLM would guess (and likely get it wrong for large numbers). With the tool, the agent delegates to a deterministic system.
What happens when you add 10 tools to one agent?
Same principle as microservices: Single responsibility. Loose coupling. Independent deployability. In n8n, this uses the AI Agent Tool node.
Three common patterns — we'll build Pattern 1 today
One parent agent receives all input. It decides which sub-agent to delegate to.
Best for: chat interfaces, multi-step tasks
Agent A → Agent B → Agent C. Fixed order. Each processes and passes to the next.
Best for: fixed data processing pipelines
Classifier categorises input, switch node routes to the appropriate agent. Deterministic.
Best for: high-volume, speed over flexibility
Today we implement Pattern 1: Orchestrator with sub-agents as tools.
Type a name → auto-research on web → structure data → save to Google Sheets
The patterns that make multi-agent systems work
Instead of hardcoding values, write $fromAI('field_name', '', 'string'). The LLM decides what value to pass at runtime.
n8n's implementation of LangChain's tool parameter specification.
Forces agent to return valid JSON matching a schema. Without it, agents return prose. With it, you get predictable structure.
Critical for inter-agent communication.
GPT-4.1-mini supports native web search. When enabled on the Chat Model node, the agent searches the web as part of its reasoning loop.
No separate API or node needed.
Stores the last N message pairs. Handles follow-ups: "Now look up their CTO" works because the agent remembers context.
Set to 10 messages for this demo.
What happens at runtime when a user types "Look up Sarah Chen from Anthropic"
Orchestrator reasons: "I need to research this person" → calls Deep Research Agent
Activates web search → finds LinkedIn, role, background → returns structured JSON
{"name": "Sarah Chen", "linkedin": "linkedin.com/in/...", "description": "ML researcher at Anthropic..."}Uses $fromAI() to populate fields → appends row to spreadsheet
"Done — Sarah Chen has been added to your leads sheet."
~4-6 agent iterations. ~10-15 seconds. The entire sequence was decided by the orchestrator at runtime — we didn't hardcode the order.
The conceptual leap from tools-as-functions to tools-as-agents
The orchestrator doesn't need to know how enrichment works. It just knows it can delegate to an agent that handles it.
An always-on AI assistant that lives in your messaging channels
Open-source assistant (Nous Research Hermes Agent) that runs on your server with persistent memory, skills, and cron.
n8n runs inspectable agent graphs. Hermes is the front door — chat, memory, skills — so users never see the canvas.
WhatsApp, Telegram, Slack, Discord, CLI — one gateway. Your keys, your VPS, your data.
Think of n8n as the hands (it executes) and Hermes as the face (it talks to you, remembers, and decides what to hand off).
Not a model provider. An assistant you operate — same posture as Week 2 Claude Code, but always-on in your channels.
The stack you leave with today
Where you already live. The channel is not the intelligence.
Personality, memory, skills, cron, and the decision to act.
Known steps and multi-agent graphs. Wire via webhook/skill as a stretch — not assumed built-in.
Real product flow — not OpenClaw Hostinger pairing
VPS recommended (or local). Follow the cohort setup sheet, or run hermes setup.
hermes model — Claude, OpenAI, OpenRouter, or Nous Portal. Add your API key.
hermes gateway setup — Telegram is fastest; WhatsApp via the built-in bridge.
Start the gateway, send a test, confirm replies with memory and tools live. Lock down allowed users before going wide.
Packaged abilities + scheduled jobs in natural language
A skill is a described ability: name, when to use it, what it does. Same craft as Week 2 Claude skills.
Hermes has a built-in scheduler. Ask in plain language for daily briefs, lead research, backups.
Every weekday at 9:00, research 5 high-fit leads for my AI product. Send results to this chat.Stretch: expose today's n8n lead router as a Hermes skill via webhook — Hermes face, n8n hands.
Part 1 required — Part 2 stretch. Full brief + build guide on the syllabus.
Ship one: fixed n8n workflow, single n8n AI agent, or live Hermes with a skill — on a real trigger, useful for your product.
Score Hot / Warm / Cold with a short reason; write score + reasoning somewhere durable.
When Hot / high priority: Slack, email, or Hermes on WhatsApp.
Channel + 2 skills + one real task. Optional: call n8n via webhook.
Empty results, bad tool calls, unauthorized senders — degrade gracefully.
This is not a UI exercise. It is a systems design exercise. Your architecture determines robustness.