Scalable multi-agent chat using mentions
Summary Engage multiple, uniquely configured AI agents (using different models via OpenRouter) in a single conversation. Trigger specific agents with @mentio...
🔌 Nodes & Integrations Used (4)
📖 Implementation & Setup Guide
Summary
Engage multiple, uniquely configured AI agents (using different models via OpenRouter) in a single conversation. Trigger specific agents with @mentions or let them all respond. Easily scalable by editing simple JSON settings.
Overview
This workflow is for users who want to experiment with or utilize multiple AI agents with distinct personalities, instructions, and underlying models within a single chat interface, without complex setup. It solves the problem of managing and interacting with diverse AI assistants simultaneously for tasks like brainstorming, comparative analysis, or role-playing scenarios.
It enables dynamic conversations with multiple AI assistants simultaneously within a single chat interface. You can:
* Define multiple unique AI agents. * Configure each agent with its own name, system instructions, and LLM model (via OpenRouter). * Interact with specific agents using `@AgentName` mentions. * Have all agents respond (in random order) if no specific agents are mentioned. * Maintain conversation history across multiple turns.
It's designed for flexibility and scalability, allowing you to easily add or modify agents without complex workflow restructuring.
Key Features
* **Multi-Agent Interaction:** Chat with several distinct AI personalities at once. * **Individual Agent Configuration:** Customize name, system prompt, and LLM for each agent. * **OpenRouter Integration:** Access a wide variety of LLMs compatible with OpenRouter. * **Mention-Based Triggering:** Direct messages to specific agents using `@AgentName`. * **All-Agent Fallback:** Engages all defined agents randomly if no mentions are used. * **Scalable Setup:** Agent configuration is centralized in a single Code node (as JSON). * **Conversation Memory:** Remembers previous interactions within the session.
How to Set Up
- **Configure Settings (Code Nodes):**
- * Open the `Define Global Settings` Code node: Edit the JSON to set user details (name, location, notes) and add any system message instructions that *all* agents should follow.
- * Open the `Define Agent Settings` Code node: Edit the JSON to define your agents. Add or remove agent objects as needed. For each agent, specify:
- * `"name"`: The unique name for the agent (used for @mentions).
- * `"model"`: The OpenRouter model identifier (e.g., `"openai/gpt-4o"`, `"anthropic/claude-3.7-sonnet"`).
- * `"systemMessage"`: Specific instructions or persona for *this* agent.
- **Add OpenRouter Credentials:**
- * Locate the `AI Agent` node.
- * Click the `OpenRouter Chat Model` node connected below it via the `Language Model` input.
- * In the 'Credential for OpenRouter API' field, select or create your OpenRouter API credentials.
How to Use
- Start a conversation using the Chat Trigger input.
- To address specific agents, include `@AgentName` in your message. Agents will respond sequentially in the order they are mentioned.
- * *Example:* `"@Gemma @Claude, please continue the count: 1"` will trigger Gemma first, followed by Claude.
- If your message contains no `@mentions`, *all* agents defined in `Define Agent Settings` will respond in a randomized order.
- * *Example:* `"What are your thoughts on the future of AI?"` will trigger Chad, Claude, and Gemma (based on your default settings) in a random sequence.
- The workflow will collect responses from all triggered agents and return them as a single, formatted message.
How It Works (Technical Details)
- **Settings Nodes:** `Define Global Settings` and `Define Agent Settings` load your configurations.
- **Mention Extraction:** The `Extract mentions` Code node parses the user's input (`chatInput`) from the `When chat message received` trigger. It looks for `@AgentName` patterns matching the names defined in `Define Agent Settings`.
- **Agent Selection:**
- * If mentions are found, it creates a list of the corresponding agent configurations in the order they were mentioned.
- * If no mentions are found, it creates a list of *all* defined agent configurations and shuffles them randomly.
- **Looping:** The `Loop Over Items` node iterates through the selected agent list.
- **Dynamic Agent Execution:** Inside the loop:
- * An `If` node (`First loop?`) checks if it's the first agent responding. If yes (`true` path -> `Set user message as input`), it passes the original user message to the Agent. If no (`false` path -> `Set last Assistant message as input`), it passes the *previous* agent's formatted output (`lastAssistantMessage`) to the *next* agent, creating a sequential chain.
- * The `AI Agent` node receives the input message. Its `System Message` and the `Model` in the connected `OpenRouter Chat Model` node are dynamically populated using expressions referencing the current agent's data from the loop (`{{ $('Loop Over Items').item.json.* }}`).
- * The `Simple Memory` node provides conversation history to the `AI Agent`.
- * The agent's response is formatted (e.g., `**AgentName**:\n\nResponse`) in the `Set lastAssistantMessage` node.
- **Response Aggregation:** After the loop finishes, the `Combine and format responses` Code node gathers all the `lastAssistantMessage` outputs and joins them into a single text block, separated by horizontal rules (`---`), ready to be sent back to the user.
Benefits
* **Scalability & Flexibility:** Instead of complex branching logic, adding, removing, or modifying agents only requires editing simple JSON in the `Define Agent Settings` node, making setup and maintenance significantly easier, especially for those managing multiple assistants. * **Model Choice:** Use the best model for each agent's specific task or persona via OpenRouter. * **Centralized Configuration:** Keeps agent setup tidy and manageable.
Limitations
* **Sequential Responses:** Agents respond one after another based on mention order (or randomly), not in parallel. * **No Direct Agent-to-Agent Interaction (within a turn):** Agents cannot directly call or reply to each other *during* the processing of a single user message. Agent B sees Agent A's response only because the workflow passes it as input in the next loop iteration. * **Delayed Output:** The user receives the combined response only *after* all triggered agents have completed their generation.
⚡ How to import this workflow into n8n:
- Click the Direct Download JSON button above to save
Scalable multi-agent chat using _mentions.json. - Log in to your n8n Cloud or self-hosted n8n instance.
- In your workflow canvas, click the menu in top-right and select Import from File (or paste the JSON directly).
- Configure your credentials (e.g. API keys, database URLs) in the corresponding node settings.
- Click Execute Workflow to test and switch to Active!
Related AI Agents Workflows
View All in AI Agents →5 ways to process images PDFs with Gemini AI in n8n
How it works Many users have asked in the support forum about different methods to analyze images and PDF documents with Google Gemini AI in n8n. This workfl...
7 AI Sales Assistant
Production-ready n8n automation template for 7 AI Sales Assistant built by AhiXLight. Seamlessly connects Airtop Tool, Slack, Airtop with 24 configured nodes.
AAVE portfolio professional AI agent Telegram Email GPT 4o
A next-generation AI-powered DeFi health monitor that tracks wallet positions across Aave V3 using GPT-4o and LangChain. It delivers human-readable reports v...
Access control for AI agents RBAC using Airtable and Telegram
Purpose This workflow allows granular control over the access to tools connected to AI Agents (including Multi-Agent setups) using Role Based Access Control....