Are the NEW Make.com AI Agents better than n8n's?

Key Concepts

AI Agents, N8N, Make.com, User Experience (UX), LLMs (Large Language Models), Prompt Engineering, Tools, Memory, RAG (Retrieval-Augmented Generation), Multi-Agent Teams, Debugging, Error Handling, Deployment, Privacy, MCP (Message Communication Protocol), Pricing, Operations, Workflows, Scenarios, Integrations, Chat Interface, System Prompt, Modules, Nodes, Vector Stores, Embedding Models, Chunking, Output Formats, JSON, Timeouts.

User Experience and Ease of Setup

• N8N: Creating AI agents is straightforward. You create a workflow, add a trigger (e.g., chat trigger), and then add an AI agent node. You can configure the system message, LLM chat model (e.g., OpenAI GPT-4), memory retention, and tools directly within the node. Testing is easy with the "open chat" feature.
  • Example: Adding a chat trigger and connecting it to an OpenAI model for immediate interaction.
• Make.com: Agents are defined upfront in a dedicated "AI Agents" tab and then embedded into scenarios. You choose a model and add a system prompt. Tools are added by selecting existing scenarios set to "scheduled on demand" or "immediately."
  • Limitation: No direct scenario creation button when adding tools; scenarios must be pre-existing.
  • Limitation: System prompt input box is initially small and not easily expandable.
  • Example: Creating a "research agent" and linking it to a Google Calendar scenario for event creation.
• Comparison: N8N's approach is more intuitive and allows for direct configuration on the canvas. Make.com's separation of agent definition and scenario embedding adds complexity.

Interfaces and Triggers

• N8N: Offers an embedded chat interface for testing agents. Supports various triggers, including webhooks, scheduled events, execution by other workflows (enabling multi-agent teams), and form submissions. Modules like WhatsApp, Telegram, and Slack can also act as triggers.
  • Example: Using a custom form submission to trigger an AI agent.
  • Example: Using WhatsApp module to trigger the agent.
• Make.com: Lacks a native chat interface for agents. Agents are triggered within scenarios, often using a variable for the message. Supports various triggers similar to N8N, such as WhatsApp, Telegram, and webhooks.
  • Limitation: Only one trigger per scenario.
  • Requires building a custom front-end for chatbot applications using webhooks.
• Comparison: N8N's native chat interface and support for multiple triggers per workflow provide greater flexibility and ease of use, especially for chatbot applications. Make.com positions agents more as reasoning engines within existing workflows.

LLMs and Reasoning

• Make.com: Offers a variety of LLMs, including OpenAI, Anthropic, Mistral, Cohere, Grok, XAI, and Gemini. You can also use OpenAI API-compatible providers.
  • Limitation: The model provider cannot be changed once the agent is created.
  • Example: Using Claude 3.7 Sonnet as a reasoning agent with the "thinking" mode enabled.
• N8N: Supports a similar range of LLMs, with additional options for enterprise solutions like Microsoft Azure, AWS Bedrock, and Vertex AI. Also supports local inference with OMA for self-hosted deployments.
• Comparison: N8N offers slightly more flexibility with enterprise and local LLM options, but the core model selection is similar between both platforms.

Prompt Engineering

• Make.com: System prompts are configured in the agent settings. Dynamic information can be added using additional system instructions within the scenario, leveraging Make.com's functions (e.g., switch, if).
  • Limitation: System prompts cannot directly include variables.
  • Workaround: Use Code Kit module to generate complex prompts with Python or JavaScript.
• N8N: System prompts can be dynamic, allowing the inclusion of variables and expressions. Code nodes can be used to generate prompts using JavaScript or Python.
• Comparison: N8N offers greater flexibility in creating dynamic and complex system prompts due to its low-code nature.

Tools

• Make.com: Tools are scenarios that the agent can access. Every module available within Make.com can technically be used within a tool.
• N8N: Offers a variety of tools, including HTTP requests, Google Calendar, and custom workflows.
  • Advantage: Direct embedding of modules without needing to wrap them in workflows.
• Comparison: Make.com has a larger number of out-of-the-box modules and integrations. N8N relies more on HTTP requests to interact with APIs, but allows direct module embedding.

Memory and Sessions

• Make.com: Offers various memory options, including simple memory (RAM-based), Redis, and Postgres chat memory. Allows setting a session key and context window length.
• N8N: Allows setting a thread ID or session ID to track interactions. The "iterations from history count" setting determines the amount of interactions retained in history.
• Comparison: N8N provides more control over memory management, while Make.com offers a more abstracted and beginner-friendly approach.

Knowledge and RAG (Retrieval-Augmented Generation)

• Make.com: Lacks native chunking functionality for RAG. Relies on third-party services like OpenAI for vector stores.
  • Workaround: Basic chunking can be achieved using regular expressions, but it's clunky and results in poor retrieval accuracy.
• N8N: Offers extensive functionality for vector stores, including document loaders, chunking strategies (e.g., recursive character text splitting), and embedding models.
  • Example: Using a JavaScript code node to implement intelligent chunking for improved RAG accuracy.
• Comparison: N8N provides superior support for RAG with native modules for chunking, embedding, and vector store integration.

Output Formats

• Make.com: Relies on system instructions to guide the output format.
  • Limitation: No option to force a specific output format like JSON.
• N8N: Allows requiring a specific output format and adding an output parser to the agent. Supports autofixing output parsers to ensure the output conforms to the defined schema.
• Comparison: N8N offers greater control over output formats, ensuring structured and reliable outputs for downstream modules.

Multi-Agent Teams

• Make.com: Theoretically possible to create multi-agent teams by using agents as tools, but clunkier to set up than N8N.
  • Potential issue: Timeouts may occur if sub-agents take too long to respond.
• N8N: Supports multi-agent teams by using agents as tools. Offers greater flexibility in managing communication and actions between agents.
• Comparison: N8N's architecture is better suited for building complex multi-agent systems.

Debugging and Error Handling

• Make.com: Provides execution data for each run, but lacks the ability to retest flows with previous data.
• N8N: Allows copying previous execution data to the editor for retesting. Offers retry on fail settings for individual nodes and the ability to define error workflows.
• Comparison: N8N provides more advanced debugging and error handling capabilities, including the ability to reload previous execution runs and configure retry mechanisms.

Deployment and Privacy

• Make.com: Only offers a cloud-based deployment option.
• N8N: Supports various deployment options, including cloud, self-hosting, and local deployment. Offers greater data privacy due to the ability to self-host and isolate the environment.
• Comparison: N8N provides greater flexibility and control over deployment and data privacy.

MCP (Message Communication Protocol)

• Make.com: Lacks an MCP solution.
• N8N: Offers an MCP client and server for integrating with tools like Claude Desktop and Cursor.
• Comparison: N8N is ahead of Make.com in adopting MCP for agent communication.

Pricing

• Make.com: Pricing is based on operations.
• N8N: Offers an open-source version that can be run for free, with costs limited to server expenses. N8N Cloud has a budget of workflow executions per month, but unlimited steps within those executions.
• Comparison: N8N is generally more cost-effective, especially for high-volume workflows, due to the availability of a free, self-hosted option.

Conclusion

N8N emerges as the superior platform for building AI agents due to its mature feature set, greater flexibility, and advanced capabilities in areas like RAG, output formatting, debugging, and deployment. While Make.com boasts a larger number of integrations, N8N's overall architecture and functionality make it a more powerful and versatile choice for both beginners and advanced users.