AI Agents and Agentic Workflows
- Oskar Schiermeister
- 3 days ago
- 8 min read
Agentic workflows might sound like something from the future – but they're already a reality. They don't follow a rigid script; instead, they decide for themselves what step to take next within predefined tools, permissions and guardrails.
You've probably heard the terms: ChatGPT Agent, Microsoft Copilot, Agentic Workflows. Maybe you've even come across specialized tools like n8n AI Agents. Suddenly, "agents" are popping up everywhere. But what does it actually mean? Is this just marketing hype again – or is there something more to it this time?
The Misconception: Agents = Autonomous Robots?
When people hear "AI agents," many think of Terminator or HAL 9000 from 2001: A Space Odyssey. Fully autonomous systems that make decisions independently and will soon replace us all. That's not the reality – at least not in 2026. An AI agent isn't an autonomous robot but an LLM with the ability to act. It cannot only understand text but also read emails, search in Notion or Google Drive, or retrieve current data from your CRM, and based on that, decide what to do next.
From Rules to Goals: The Fundamental Difference
Traditional automation works like a recipe. If X happens, then do Y. Fixed sequence, no deviation. An error means complete failure. Agentic workflows work differently. First, you set a goal. For example, "Summarize the key points from the last team meetings”, and from there the agent decides for itself:
Which meeting notes are relevant?
Do I also need the project roadmap?
Should I include the Slack discussions as well?
"The shift from process automation to goal automation is the most significant change in how we think about AI systems." – Andrew Ng, deeplearning.ai
Andrew Ng calls this the difference between "Process Automation" and "Goal Automation." Instead of specifying every single step, you define the desired outcome and the agent finds its own way there.
What's Really Behind an Agent?
A functioning agent consists of four components that must work together:
The "Brain" (LLM): A reasoning model like GPT-4o, Claude Opus 4.5, or Gemini 2.5 Pro understands the task and plans the necessary steps. It's the decision-maker.
Access to External Systems: The agent can "talk" to other programs – search your CRM system, check calendar entries, read emails, or query company databases. This happens through standardized interfaces (APIs), similar to how apps on your smartphone can access your contacts.
Memory & Context: The agent remembers previous steps. If it learned in step 1 that the customer is a premium customer, it takes that into account in all subsequent decisions.
Human-in-the-Loop: For critical decisions, humans are involved. No agent should act fully autonomously today – especially not when it comes to money, legal matters, or important customer relationships.
Practical Example: Intelligent Customer Onboarding
Let's make the difference concrete.
Before (traditional automation): A customer fills out a form. The system checks whether all fields are filled in. If yes, an email is sent and a ticket is created. If no, it shows an error. Problem: The customer only forgot their date of birth but has an urgent pricing question. The system blocks – even though the question has nothing to do with the date of birth.
After (agentic workflow): The agent analyzes the form and understands: "Date of birth is missing, but the actual request is time-sensitive and concerns pricing." It creates a priority ticket, sends a friendly confirmation email noting the missing date, and forwards the pricing question directly to sales – without making the customer wait.
Another example is email triage. A traditional system sorts by keywords ("invoice" → accounting). An agent reads the entire email, understands the context, checks the customer history in the CRM system, and decides: "This is a complex complaint with legal aspects. It needs to go to the Head of Customer Success, not to the standard support queue."
Where Agents (Still) Hit Their Limits
As promising as agents are, they're not perfect:
Hallucinations: LLMs can generate convincing but false information. An agent might answer a customer inquiry in a way that sounds plausible but is factually wrong.
Governance Questions: Who is liable if the agent accidentally quotes a wrong price to a customer? These legal questions haven't been definitively resolved yet.
Compliance Risks: In regulated industries like medicine, finance, or law, there are strict regulations. An agent that automatically makes credit decisions could inadvertently violate anti-discrimination laws.
That's why agentic workflows work best with human checkpoints for critical decisions – the so-called "human in the loop." For routine tasks with low risk? The agent can act independently. For important business decisions? Only with human oversight.
Practice: How to Build an Agent with n8n
Let’s start with a concrete example to understand what problem an agent solves and how it makes decisions.
Example Workflow: Weekly Team Briefing
Every week, teams produce scattered information: meeting notes, action items, follow-ups, and open questions across different tools. Manually collecting and summarizing this information is time-consuming and error-prone. In this workflow, the agent is triggered every Monday at 8:00 AM. Its goal is simple: create a concise weekly briefing for the team.
To achieve this, the agent:
Searches meeting notes from the past week
Identifies the most relevant discussions and decisions
Summarizes key points into a short briefing
Sends the summary via email to the team
If something is unclear or missing, it asks for clarification via Slack before sending
This is not a fixed script. The agent decides what information matters and whether it has enough confidence to proceed, escalating to humans only when necessary.
What decisions does the agent make?
Even in this simple example, the agent makes several decisions on its own:
Which meetings are relevant for the weekly summary?
Are Slack discussions important enough to include?
Is the available information sufficient, or is clarification needed?
Can the briefing be sent automatically, or should a human be consulted first?
These decisions are what distinguish an agentic workflow from traditional rule-based automation.
How this is implemented with n8n
To enable these decisions in practice, the agent needs structure, tools, and access to external systems. This is where n8n comes in.
n8n is an open-source platform for workflow automation with over 400 integrations. Since 2025, it has become one of the most popular tools for building AI agents thanks to native LangChain integration and direct connections to vector stores.
A simple agent in n8n consists of four building blocks:
Trigger: The initiator, for example a scheduled event, chat message, or webhook
AI Agent Node: The core component, where you define the agent’s behavior using system prompts
LLM Connection: The connection to models like GPT-4o, Claude Opus 4.5, or Gemini 2.5 Pro
Tools: The actions the agent can take, such as searching Google Drive, reading emails, or querying APIs
The special thing: you don’t need to write code. n8n’s visual interface allows you to build complex agentic workflows via drag-and-drop. For developers, there is still the option to insert custom code where more control is required.
Important: “No-code” doesn’t mean “no skills.” Even though n8n doesn’t require programming, you should understand basic technical concepts such as APIs, webhooks, and JSON. Without this foundation, troubleshooting quickly becomes frustrating. If you’re new to automation tools, plan some time to get familiar with these basics.
What Does an AI Agent Cost to Run?
AI agents are billed via API calls – and costs can add up quickly if you're not careful. Here's an overview of current prices:
Model | Input (per 1M Tokens) | Output (per 1M Tokens) | Source |
GPT-4o | $2.50 | $10.00 | |
Claude Opus 4.5 | $5.00 | $25.00 | |
Claude Sonnet 4.5 | $3.00 | $15.00 | |
Gemini 2.5 Pro | $1.25 | $10.00 |
As of January 2026. Prices may change – find current prices on the providers' linked pages.
What does this mean in practice?
1 million tokens ≈ 750,000 words
A typical agent request: approx. 2,000–5,000 tokens (input + output)
1,000 agent runs per month with GPT-4o: approx. $5–15
Example calculation: An agent that categorizes 50 emails daily (about 500 tokens input, 200 tokens output each) costs about $1.50 per month with GPT-4o. With Claude Opus 4.5, it would be around $5, but you get better reasoning capabilities.
Cost-saving tips:
Prompt Caching: Save up to 90% with repeated context
Batch Processing: 50% discount for non-time-critical tasks
Model Routing: Simple tasks to cheaper models, complex ones to premium models.
Traditional Automation vs. Agentic Workflows
Criterion | Traditional Automation | Agentic Workflow |
Logic | If-then rules | Goal-based |
Error tolerance | Fails on deviations | Adapts, finds alternatives |
Flexibility | Only predefined paths | Dynamic decisions |
Setup | Quick for simple flows | More planning, but more flexible |
Maintenance | Every change = new flow | Agent learns from context |
Costs | Usually free or cheap | API costs per run |
Use case | Repetitive, predictable tasks | Complex, variable tasks |
When to use what?
Traditional Automation: Automatically file invoices, sync calendar entries, transfer form data to CRM
Agentic Workflow: Prioritize emails by urgency, create meeting summaries, complex research tasks
Use Case: Customer Support Agent
The Problem: Every day, 200 support tickets come in. Some are urgent, some aren't. Some belong to the tech team, some to accounting. Currently, a human sorts this, or tickets end up in the wrong place, customers wait, frustration builds.
What the Agent Does for You: Every ticket is immediately analyzed: What's it about? How urgent is it? Is the customer upset? Do they have open orders or previous complaints? Based on this, the ticket automatically lands with the right team – with a brief summary and relevant context from the CRM.
How It Works: The agent reads the ticket, identifies the topic (technical problem, billing question, general inquiry, complaint) and checks in the background who the customer is. A premium customer with an open issue? Moves up in priority. A standard question that's been answered 100 times before? The agent suggests an answer from your knowledge base and an employee just needs to confirm and send.
Technical Implementation:
Workflow Steps:
Trigger: New ticket in helpdesk (webhook)
LLM analyzes ticket content and tone
CRM query: Customer status, history, open cases
LLM categorizes: Technical / Billing / General / Complaint
LLM assesses urgency (1-5)
For standard questions: Knowledge base query for suggested response
Routing to responsible team with context summary
Tools & Integrations:
n8n or Make as workflow platform
Helpdesk with API (Zendesk, Freshdesk, Intercom)
CRM with API (HubSpot, Salesforce)
Knowledge base / Vector store for response suggestions
LLM: GPT-4o or Gemini 2.5 Pro
Estimated Costs: ~800 tokens input (ticket + CRM context) + ~400 tokens output = approx. $0.015 per ticket with GPT-4o
Two Paths: Build or Buy?
The workflow above shows how to build this agent yourself with n8n or Make. But there's another option: specialized platforms that deliver contact center AI out of the box.
Aspect | Build Yourself | Use a Platform (e.g., Parloa) |
Setup | Node by node, connection by connection | Pre-built modules, configuration via UI |
LLM Choice | Freely selectable (GPT-4o, Opus, Gemini, open source) | Usually predetermined or limited |
Integrations | Self-built via API | Ready-made connectors available |
Hosting | Your responsibility (cloud or on-premise) | Managed by platform |
Compliance | Ensure yourself | Certifications included |
Debugging | Full transparency into every step | Abstraction, less visibility |
The Rule of Thumb:
Build yourself if you want to understand and control
Use a platform if you need to scale quickly and compliance is important
Autonomy Level: Low to Medium Whether you build or buy – the agent sorts and suggests, but doesn't respond independently. Every customer response goes through a human. Only when you see that certain suggested responses are adopted unchanged 95% of the time can you consider automating those.
What's Coming Next?
Development is heading in three directions:
Multi-Agent Systems: Multiple specialized agents work together. One agent is an expert in research, another in writing, a third in quality control. They pass results to each other – like a team.
Orchestrator Models: "Meta-agents" coordinate other agents. Imagine a project manager who assigns tasks to various specialists and brings together the overall result.
Model Context Protocol (MCP): Anthropic has developed standardized interfaces that are currently establishing themselves as a standard. This allows agents to communicate more easily with different programs, comparable to USB ports that work with many devices.
In 2026, we won't see "full autonomy," but significantly smarter, more adaptable workflows that understand what they're doing.
Takeaway: The Middle Path Is the Right Path
Agentic workflows are neither science fiction nor old wine in new bottles. They are the middle ground between rigid automation and fully autonomous AI, and that's exactly where their practical value lies.
Those who understand the concepts today can build the right systems tomorrow. The question isn't whether you should use agents, but where and how much autonomy you give them. Start with low risk: Let the agent categorize emails before you allow it to sign contracts.
The next generation of automation thinks for itself – but the responsibility remains with us.
