Modular AI Agents — Overview

Modular AI agents are the recommended way to build agents in Floogos. Instead of configuring everything inside a single node, you assemble an agent by connecting pieces: an orchestrator node in the center and, around it, the nodes that give it capabilities (the brain that reasons, the tools it can run, the knowledge base it queries and the skills it activates depending on the request).

It’s the same mental model as n8n: typed ports where you drag each piece into place.

When to use this instead of the monolithic Agent node?

The classic AI Agent node still exists and works (everything is configured via fields). Use modular agents when you want to freely mix LLM providers, expose any node in the catalog as a tool, add RAG, or encapsulate behavior in reusable skills.

The idea in one picture

The orchestrator enters and exits the normal flow (left → right). On its bottom edge it has four typed ports where the sub-nodes connect. Those connections are not data flow: they declare “this piece is part of this agent”.

The pieces

Each piece has its own detail page with examples:

AI Agent (orchestrator)

The operational core. Discovers the connected pieces, builds the prompt, calls the LLM and runs the function calling loop (request tool → run it → return result → repeat).

See detail →

Brain (LLM)

The model that reasons. You pick a provider (OpenAI, Claude, Gemini, Mistral, Kimi, Groq, local LLM…) and a model. One brain per agent.

See detail →

Tool

A capability the agent can invoke: any of Floogos’ 600+ nodes, a whole workflow, or a registered tool. You can connect several.

See detail →

RAG (retrieve / ingest)

Vector knowledge base. RAG (ingest) loads documents; RAG (retrieve) connected to the agent injects the relevant context before answering.

Ingest → · Retrieve →

Skill

A package of instructions + tools the agent activates only when the request is relevant to its description. Claude-style “skills”.

See detail →

How it works inside

1. Discovery. When it runs, the orchestrator looks at the graph and finds the sub-nodes that point to it (each one internally carries attach_to = agent alias and a role). It groups them into: brain (1), tools (N), rag (N), skills (N).

2. Prompt assembly. It starts from the configured system prompt. If there are skills relevant to the request, it injects their instructions. If there is RAG, it retrieves the chunks most similar to the query and adds them as context.

3. First LLM call. It sends the prompt + the user’s message + the schema of the available tools.

4. Tool loop. If the LLM decides to use a tool, the agent runs it (executes the real node/workflow), returns the result and calls the LLM again. It repeats until the model answers without requesting more tools, or max_iterations is reached.

5. Answer. It returns the agent’s final text and continues the normal flow.

The connection contract (the important bit)

Each sub-node belongs to an agent through two values in its configuration:

• attach_to — the alias of the AI Agent node it belongs to (e.g. aiAgent_1).
• role — its function: brain, tool, rag or skill.

In the editor you don’t need to type these by hand: when you drag a sub-node’s output onto the matching port of the agent, Floogos sets attach_to and role automatically. The attach_to text field remains as a manual fallback (or for import/export).

One brain only

The brain port accepts exactly one connection. If you connect a new brain, it replaces the previous one. The tools, rag and skills ports accept several.

Keep reading

• Node reference — each node with its fields.
• How to combine the nodes — the wiring logic step by step.
• Examples and recipes — complete, copy-ready cases.
• Common problems and solutions — what fails and how to configure it right.
• Agent library — ready-made skills, tools, prompts and kits to insert into your agent.