This is the year of the agents, they said. Everyone needs agentic workflows in their products, they said. Yeah, yeah, but what does that actually mean?!
In two words: automating stuff. In actuality, pinning down a definition is a lot more complicated than that (as Dave Ebbelaar explains in this brilliant video).
We now have "artificial intelligence" in the true sense of the word (because AI probably doesn't "think" like we think it does), but to make it actually useful, it needs to actually do stuff for us.
Cause let's face it. We're all pretty much drowning in digital busywork. Managing emails, copying data between spreadsheets, posting the same update to five social media accounts, compiling that weekly report... It's exhausting. These repetitive digital chores eat up hours we could spend on thinking, creating, or strategizing.
It’s not just annoying; it’s inefficient, prone to errors, and holds back real progress. Work progress, and real life progress (cause we spend too much time working!).
Fortunately, just about every AI company is working on fixing this for us with "agents." In actuality, what most of them are doing is called workflow automation. All that means is setting up sequences of repeatable tasks within your software to run automatically. So instead of wrestling with individual apps, you can design automated processes that fit your needs, creating little self-operating systems for the stuff you do over and over.
Add a "language model" (like ChatGPT) to the mix to help make decisions, and boom: you've got an agent.
So how do you, a regular human, make an AI agent (or more simply, automate your stuff)? No code AI tools!
The No-Code Revolution = Automation for Everyone
What makes "agentic workflows" possible for everyone, not just programmers, is no-code and low-code automation platforms. These are software tools that let you build automations visually, often without writing a single line of code. Think of them like digital LEGOs for your workflow.
The basic idea is simple: you connect Triggers (an event that starts the process, like getting a new email or a form submission) with one or more Actions (the tasks the automation performs, like saving that email's attachment or adding the form data to a spreadsheet). Even complex automations often boil down to this "WHEN this happens, DO that" logic.
This is a huge deal because it democratizes technology. People who actually understand the business problems and processes—often called “citizen developers”—can now build the solutions themselves, without needing extensive coding training or waiting for overloaded IT departments.
This speeds things up, sparks innovation everywhere, and frees up IT for the really complex stuff. It's predicted that most new business apps will soon be built using these platforms, driven by this empowerment.
Meet Your Automation Toolkit.
Several powerful platforms lead the charge:
1. Make.com: The Visual Powerhouse
Make is famous for its super visual, interactive workflow builder. You literally drag modules (representing apps) onto a canvas and connect them. What's cool is you can see the data flowing between steps, making it easier to understand and fix complex automations. It feels polished and business-ready.
- Good for: People who like visualizing complex flows, tasks needing sophisticated logic (branching, looping), handling different data types (JSON, CSV), business users, and enterprises needing features like GDPR/SOC2 compliance.
- Key Features: Intuitive visual builder, 1000+ app connections, advanced flow controls (routers, iterators), strong data manipulation tools, real-time triggers (like webhooks), AI integrations.
- Downsides: Can have a learning curve for very complex setups; price is based on "operations," which can get costly for high-volume data processing.
2. N8N: The Flexible, Coder-Friendly Option (Often Free!)
N8N's big draw is being open-source and self-hostable. This means you can run it on your own servers (even offline!), giving you maximum control over data privacy and security. It uses a node-based visual editor (connecting blocks), but its real superpower is letting you drop in custom JavaScript or Python code right into your workflow for ultimate customization. The cool kids often prefer N8N for its flexibility.
- Good for: Technical users, developers, IT/DevOps, anyone prioritizing data control, those needing custom code logic, building AI agents (good LangChain integration), potentially saving costs via self-hosting.
- Key Features: Node-based editor, 400+ native integrations (plus connects to any API), deep code integration, complex logic support, AI capabilities, developer tools (version control, environments), self-hosting (free community version) & cloud options.
- Downsides: Steeper learning curve for non-techies; self-hosting needs technical know-how for setup/maintenance; interface sometimes seen as less slick; some enterprise features are paid.
3. Zapier: The King of Connections
Zapier is probably the most famous name here. Its superpower is connecting to a massive number of apps (over 7,000!). It's built for simplicity, focusing on easy "Trigger -> Action" workflows called "Zaps."
- Good for: Beginners, quickly connecting lots of different web apps, simple to moderately complex automations, leveraging a huge library of pre-built templates.
- Key Features: Extremely user-friendly, unparalleled app library (7000+), multi-step Zaps (paid), conditional logic (Filters/Paths), scheduling, built-in utilities, expanding into Tables, Interfaces, and AI Agents.
- Downsides: Pricing is per "task" (successful action), which can get expensive fast for high-volume workflows; offers less fine-grained control over complex logic or data compared to Make/N8N; limited native code integration.
4. Microsoft Power Automate: The Ecosystem Player
Part of the broader Microsoft Power Platform, Power Automate shines brightest if you're already living in the Microsoft world (Office 365, Dynamics, Azure). Its unique strength is built-in Robotic Process Automation (RPA), letting you automate tasks on your actual desktop – clicking buttons in old software that doesn't have an API.
- Good for: Organizations heavily using Microsoft products, automating desktop tasks (RPA), integrating AI using Microsoft's tools (AI Builder, Copilot), enterprise environments needing strong governance.
- Key Features: Deep Microsoft integration, powerful RPA (attended/unattended bots), many connectors (Microsoft & third-party), AI Builder for integrating AI models, Process Mining tools, Dataverse integration, Copilot features.
- Downsides: Can be complex, especially licensing; might feel less intuitive if you're not a Microsoft regular; connecting non-Microsoft apps can sometimes be clunkier.
What About AI Agents?
Okay, back to “agents.” While the tools above are great for rule-based automation (IF this, THEN that), AI Agents are the next step. They aim to be smarter and more autonomous.
There’s lots of definitions of agents, but the one that makes the MOST sense to us (from Latent Space) is this:
Agent = language model plus memory plus planning skills plus tool use.
Let’s break that down:
- Language model = the "brain" a.k.a an AI like ChatGPT or Claude. You input language tokens (AI speak for words turned into numbers), you get language tokens output back atcha.
- Memory = the ability to remember context and past interactions (like a large context window or external database).
- Planning skills = “thinking mode”, which is basically just the capacity to break down a goal into steps and figure out how to achieve it, maybe trying different approaches.
- Tool use = the crucial ability to interact with the outside world – use APIs, run code, search the web, control other software (sometimes via standards like Model Context Protocol or MCP).
A lot of companies (and we mean, A LOT of companies) offer “agents” that are some combination of all of the above. Not all of these are real agents, though.
What makes a true agent different from an “agentic workflow” (fancy talk for putting a series of automated steps together that involve AIs) is an agent does the reasoning and planning for you—so instead of you deciding the best way to do everything in the above example, the AI does. (Jeff Su explains this well).
Think of it this way: a workflow automation follows a detailed recipe perfectly, while an AI agent is more like a chef who looks at the ingredients (your request and available tools) and figures out how to make the desired dish, potentially improvising along the way.
Examples include agents that can:
- Do complex research online, synthesize findings, and write reports.
- Handle nuanced customer support issues.
- Automate tasks within complex software by understanding the interface.
- Plan and book travel based on budget and preferences.
For example, the popular trend now is making “browser use” agents like OpenAI’s Operator, China’s Manus, or the appropriately named “Browser Use” that can navigate the web like humans can (there’s also LMNR, which we tested this weekend).
BTW, the most powerful agents use multiple language models to accomplish different tasks in a workflow.
Example: Say you’ve got your planning AI, who passes to your writer AI, who passes to your editor AI, who maybe passes to a fact checker AI, and then your publisher AI.
Put all those together, and you’ve essentially got a “publishing agent” that can publish complete works for you.
Many platforms (Zapier, N8N, Microsoft) are already integrating these agent-like capabilities. You can also build them using frameworks like CrewAI or LangChain.
Often, the best approach is a hybrid: use a reliable workflow tool for the simple steps, then call an AI agent for the parts needing complex reasoning or understanding.
So how do you make your own agent? Now, in order to make your OWN agent (to automate anything), we’ll focus first on the “original” version of an agent (the agentic workflow) so you can practice thinking through everything you need to tell your AI to do for you.
The two main tools non-coders (and some coders) use to do this are Make and n8N. Make is the every man’s tool, while n8n is the coder’s preference (it’s kinda like the Claude to Make.com’s ChatGPT—all the cool kids use n8n).
We recommend learning n8n, but it feels really complicated to use, like, as soon as you start. Luckily, Tina Huang put together this epic tutorial, and n8n has their own tutorial series, too.
That said, if Make is more your style, this tutorial from Helena Liu is the one for you
Getting Started: Your First Automations
The best way to learn is by doing. Starting with simple, tangible tasks can quickly demonstrate value and build confidence. These small victories often provide the motivation needed to tackle more complex automations later, helping overcome any initial learning curve.
How to use Make.com:
For example, a common goal for creators and businesses is maintaining a consistent social media presence. YouTuber Helena Liu created a tutorial on how to use Make.com to read a news article URL from a Google Sheet, have AI summarize it and write multiple social media posts, generate an image, and potentially post them automatically. This is a very popular tutorial (1M views and counting) and its really easy to follow along with for you to try yourself.
Scenario Goal: When a new article URL is added to a Google Sheet, have AI summarize it, generate tailored posts for Facebook, Instagram (with image), Twitter/X, and LinkedIn, and either post them or send them for approval.
Steps:
- Prepare Google Sheet: Create a Google Sheet with at least one column, named something like News Link. Add the URL of an article you want to post about in the first row under this column.
- Create New Scenario & Trigger: In Make.com, click "Create a new scenario". Click the central +, search for Google Sheets, and select the Watch New Rows trigger.
- Configure Google Sheets Trigger: Click "Add" to connect your Google account. Select the Spreadsheet you just created. Select the specific Sheet (e.g., 'Sheet1'). Set the Limit to 1 (to process one article URL at a time). Click OK.
- Set Schedule: Click the clock icon on the Google Sheets module. Change the schedule from the default (e.g., 'Every 15 minutes') to Every day and set a desired time (e.g., 8:00 AM). Click OK.
- Add Perplexity for Summarization: Click the + next to the Google Sheets module. Search for Perplexity and select Create a Chat Completion.
- Configure Perplexity: Click "Add" to connect your Perplexity account by pasting your API key (found in Perplexity account settings under API). Choose a model (Helena used llama-3-sonar-large-32k-online). In the Messages section, add an item: Set Role to User. In the Content field, type a prompt like: Summarize this article: then map the News Link column output from the Google Sheets trigger. (Click in the field, find the Google Sheets icon, and select the column name). Click OK.
- Test Summarization: SAVE YOUR WORK! (Make doesn't autosave). Click "Run once". Check the output bubble on the Perplexity module (click the number, then the magnifying glass). Expand Output -> Choices -> Message -> Content to see the AI-generated summary. If it looks good, proceed.
- Add Router for Parallel Posts: Click the + next to Perplexity, search Flow Control, and select Router. This splits the workflow to create posts simultaneously. Click the Router to add multiple paths branching off it (Helena used four).
- Generate Posts (One Branch per Platform):
- Facebook (Claude): Click + on a router path. Search Claude, select Create a Message. Connect your Claude API key. Select Model (Helena used Claude 3 Opus). Set Role to User. In Content, type your Facebook prompt (Helena's example: Act as a social media manager and generate a Facebook post. The post should engage... include hashtags. Here's the summary:) then map the Perplexity summary output (Choices -> Message -> Content). Click OK.
- Instagram Text (OpenAI): Click + on another router path. Search OpenAI, select Create a Completion (Chat). Connect your OpenAI API key. Select Model (Helena used gpt-4). Add Message: Role User. In Content, type your Instagram prompt (Helena's: As a digital marketing specialist create an Instagram post about the following... include inspirational message, use emojis... suggest hashtags. Here's the summary:) then map the Perplexity summary output. Set Max tokens (e.g., 2000). Click OK.
- Instagram Image (OpenAI DALL-E): After the Instagram Text node, click +. Search OpenAI, select Generate an Image. Connect credentials. Select Model (DALL-E 3). Type a prompt for the image (this could reference the article summary or the generated Instagram text). Set Size/Quality. Click OK.
- Twitter/X (OpenAI): Click + on another router path. Add OpenAI -> Create a Completion (Chat). Configure credentials, model, role. In Content, type your Twitter/X prompt, mapping the Perplexity summary. Set Max tokens. Click OK.
- LinkedIn (Claude): Click + on the last router path. Add Claude -> Create a Message. Configure credentials, model (Opus), role. In Content, type your LinkedIn prompt, mapping the Perplexity summary. Click OK.
- Test Generated Content: SAVE AGAIN! Click "Run once". Check the output bubbles for each LLM module (Claude/OpenAI) to see the generated posts. Check the DALL-E output for the image URL and view the image. Refine your prompts in each module until the outputs meet your needs (e.g., shorter Instagram text, image style).
- Connect to Social Platforms (Choose One Path):
- Path A: Direct Posting: After each relevant generation module, add the corresponding social media module: Facebook Pages -> Create a Post, Instagram for Business -> Create a Photo Post, X (Twitter) -> Create a Tweet, LinkedIn -> Create a Simple Text Post. Connect your accounts. Map the generated text from the correct preceding AI module to the 'Message'/'Caption' field. For Instagram, map the generated image URL from the DALL-E node to the 'Photo URL' field.
- Path B: Approval Workflow (Recommended First): Instead of connecting directly to social media, unlink those connections (right-click -> unlink). After each generation module, add an Email module (like Gmail -> Send an email). Configure it to send the generated text (and image URL for Instagram) to your email address. Review the AI's output daily via email, refine prompts as needed in Make. Once you're confident, switch to Path A.
- Activate: Once testing (either via approval emails or direct test posts) is successful, ensure all desired final connections are made, SAVE, and toggle the scenario "ON" using the switch at the bottom left.
- Maintain: Keep adding new article URLs to your Google Sheet row by row for the automation to run daily.
Helena chose Make because she liked its visual, no-code nature, allowing her (and you) to create complex AI automation without programming.
She chose Perplexity for its real-time web access (at the time of recording; these days, Claude, ChatGPT, and Gemini 2.5 with grounding in AI studio can all do this) and chose Claude and OpenAI for post generation based on their perceived output quality (again, these days Gemini 2.5 via API might be your best bet if you steer it with your own custom writing style preferences).
Oh, and don't both using DALL-E either; these days, ChatGPT's image generator is one of the best available.
How to use N8N:
Now let's build something a bit more sophisticated, showcasing how these platforms can integrate AI. This example, inspired by a live stream tutorial from YouTuber Tina Huang, demonstrates creating a simple AI assistant in N8N that can read your Google Calendar and even schedule new events via a Telegram chat interface.
Scenario Goal: Interact with a Telegram bot to ask about today's schedule or request new events to be added to Google Calendar, with an AI agent handling the requests and using the appropriate tools.
Steps:
- Create New Workflow: Start a new workflow in your N8N instance.
- Add Telegram Trigger: Add the Telegram Trigger node. Connect your Telegram bot credentials (create a bot via Telegram's BotFather and get the API token). This node listens for incoming messages to your bot.
- Add Switch Node (Routing): Add a Switch node connected to the trigger. This routes the workflow based on input type. Configure it to check if the incoming message is text or voice/audio.
- Path 1 (Text): If its text, pass the message content directly to the AI agent.
- Path 2 (Voice): If it's voice, connect to an OpenAI node configured for the Whisper model. This node transcribes the audio to text. Pass the transcribed text to the AI agent. (Tina included this voice option for flexibility).
- Keep in mind you’ll need to connect your OpenAI API key.
- Add the Core AI Agent Node: Add the AI Agent node (or a specific LLM node like OpenAI Chat Model configured for agentic behavior). Connect both the text path and the transcribed voice path to its input.
- Configure the AI Agent Node:
- Connect your LLM: Select your desired language model (e.g., OpenAI GPT-4o) and connect your API key credentials.
- Define System Prompt: This is critical! Click into the agent node's settings. In the System Message field, give the AI its instructions and context.
- Tina Huang used a prompt similar to: “You are a helpful assistant. I will give you tasks or ask about my schedule. You will read my Google Calendar events for today to answer questions. If asked to schedule something, help me prioritize and schedule time-blocked events. You have access to the following tools: 'Read Calendar Event' and 'Create Calendar Event'. Make sure you know today's date and only work with today's events.”
- Crucially, clearly naming the tools here is vital for the AI to know what it
- Add Tools: This is where you grant the AI its capabilities.
- Tool 1. Read Calendar Event:
- Add a Google Calendar node. Name it exactly as referenced in the system prompt (e.g., Read Calendar Event).
- Connect your Google Calendar credentials.
- Set the Operation to Get Many (to read events).
- Select your primary calendar ID.
- Configure the 'Start Time' and 'End Time' fields (e.g., using N8N expressions like {{ new Date().toISOString() }} for today, potentially limiting the end time to the end of the day) to restrict the search.
- Tool 2. Create Calendar Event:
- Add another Google Calendar node.
- Name it exactly as referenced (e.g., Create Calendar Event).
- Connect credentials.
- Set Operation to Create.
- Select your calendar ID.
- Here's the tricky part Tina debugged live:
- By default, N8N might schedule for “now.” To let the AI decide the time/title based on the user's request (e.g., “schedule gym at 3 pm”), you must use N8N's AI parameter placeholders.
- Go to the 'Start Time' field, change the mode from 'Fixed' to 'Expression', and enter the placeholder syntax provided by N8N for AI parameters, typically something like {{ $json.ai.parameters.start }}.
- Do the same for 'End Time', using {{ $json.ai.parameters.end }}.
- Click 'Add Field', search for 'Summary' (which corresponds to the event Title), set its mode to 'Expression', and use {{ $json.ai.parameters.title }}.
- Crucially, within the tool configuration itself (often under an 'AI Parameters' or similar section), define these parameters (start, end, title) with clear descriptions for the AI (e.g., for start: "The date and time the event should start, e.g., 'YYYY-MM-DDTHH:MM:SS'"; for title: “The title or summary of the event").
- This tells the AI what kind of information to fill into those placeholders when it decides to use the 'Create Calendar Event' tool.
- By default, N8N might schedule for “now.” To let the AI decide the time/title based on the user's request (e.g., “schedule gym at 3 pm”), you must use N8N's AI parameter placeholders.
- Tool 1. Read Calendar Event:
- Add Telegram Send Node: Add a Telegram Send Message node. Connect the output of the AI Agent node to it. Configure it with your bot credentials. Map the AI agent's final response (e.g., {{ $json.output }} or similar) to the 'Text' field. This sends the AI's answer back to the user in Telegram.
- Test Rigorously: Use the “Execute Workflow” or “Test Node” features extensively.
- Send a text message like “What events do I have today?”
- Check if the AI uses the 'Read Calendar Event' tool and gives the correct schedule.
- Send "Schedule lunch with Bob at 1 pm for 30 minutes."
- Check if the AI correctly parses the time, duration, and title, uses the 'Create Calendar Event' tool with the right parameters (placeholders), and if the event appears correctly in your Google Calendar.
- As Tina found, you might need to tweak the system prompt or tool parameter descriptions if the AI misunderstands.
- Send a text message like “What events do I have today?”
- Activate Workflow: Once satisfied, toggle the workflow ON.
This example, following Tina Huang's live demo, shows how N8N (and similar tools) can orchestrate triggers, AI reasoning, and specific tool actions to create a useful, albeit simple, AI assistant.
It also highlights the iterative testing and occasional “finicky” nature of getting AI parameters right in a no-code environment.
Common Starting Points & Use Cases
Beyond these examples, beginners can explore numerous other valuable automations:
Here are a few simplified ideas based on the tutorials we watched:
Auto-Save Email Attachments with Make.com:
- Start a new Make scenario.
- Add an Email trigger (connect your Gmail/Outlook). Choose folder (Inbox) and criteria (has attachments).
- Add a Google Drive action (connect your Drive). Choose the destination folder.
- Map the 'Attachments' data from the Email trigger to the 'Upload a File' action in Drive. Make will often guide you on splitting multiple attachments (using an Iterator).
- Set a schedule (e.g., every hour) and turn it ON. Voila! Important attachments saved automatically.
Auto-Post Blog Updates to Social Media with N8N:
- Start a new N8N workflow.
- Add an RSS Feed Reader trigger. Paste your blog's RSS feed URL.
- (Optional) Add an OpenAI/Gemini node to draft a social post based on the RSS item's title and link. Connect your API key and write a prompt like "Draft a short LinkedIn post about: {{ $json.title }} {{ $json.link }}".
- Add LinkedIn and Twitter/X nodes. Connect your accounts.
- Map the text (from RSS or AI node) to the 'Message' field in each social node.
- Test the workflow, then Activate it. New blog posts now auto-share!
How to think about automating anything:
- Choosing Your Tool: Consider your tech comfort, budget, specific app needs (Zapier's breadth vs. Power Automate's Microsoft focus), and need for control (N8N self-hosting). Start with free tiers!
- Know the Limits: You can't automate everything. Tasks needing deep creativity, empathy, complex physical actions, or subjective human judgment are still human domains. No-code tools also have limits on customization, scale, and complex logic compared to custom code. AI agents are powerful but can still be unreliable or "hallucinate."
- Start Simple: Pick a small, annoying, repetitive task first. Build confidence.
- Map It Out: Understand your manual process before trying to automate it.
- Test, Test, Test: Automations can go wrong. Test thoroughly!
Monitor & Refine: Keep an eye on your workflows and tweak them as needed.
