> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evo-ai.co/llms.txt
> Use this file to discover all available pages before exploring further.
# Agent Types
> Learn about all the agent types available on the Evo AI platform and choose the ideal one for your use case
## Overview
The **Evo AI** platform offers different types of agents, each optimized for specific use scenarios. From simple LLM-based agents to complex workflows with multiple steps, you can choose the approach that best adapts to your needs.
**Smart Choice**: Each agent type has been designed to solve specific problems. Use this guide to identify which type best serves your use case.
## Available Types
### Fundamental Agents
**Base agent with LLM**
Fundamental agent based on Large Language Models, ideal for conversations, text analysis, and tasks requiring natural language understanding.
**When to use:**
* Intelligent conversations
* Text analysis
* Content generation
* NLP tasks
**Features:**
* Chat interface
* Multiple LLM models
* Personality configuration
* Sub-agent system
**Integration with A2A protocol**
Integrates external agents that implement Google's Agent-to-Agent (A2A) protocol, enabling interoperability with external systems.
**When to use:**
* Integration with legacy systems
* External specialized agents
* AI microservices
* Third-party APIs
**Features:**
* JSON-RPC 2.0 protocol
* Standardized communication
* Automatic health checks
* Circuit breakers
### Orchestration Agents
**Ordered sequential execution**
Executes multiple sub-agents in ordered sequence, where each agent receives the output of the previous one as input.
**When to use:**
* Processing pipelines
* Linear workflows
* Dependencies between steps
* Data transformation
**Features:**
* Step-by-step execution
* Data passing between agents
* Failure control
* Detailed logs
**Simultaneous parallel execution**
Executes multiple sub-agents simultaneously, ideal for independent tasks that can be processed in parallel.
**When to use:**
* Independent analyses
* Distributed processing
* Time optimization
* Unrelated tasks
**Features:**
* Simultaneous execution
* Result aggregation
* Concurrency control
* Significant speedup
**Iterative execution with refinement**
Executes sub-agents in iterative loops, refining results with each iteration until reaching convergence criteria.
**When to use:**
* Iterative refinement
* Parameter optimization
* Progressive improvement
* Result convergence
**Features:**
* Controlled iterations
* Stop criteria
* Convergence monitoring
* Infinite loop prevention
**Complex visual workflows**
Creates complex workflows with visual interface using LangGraph and React Flow, offering maximum control and flexibility.
**When to use:**
* Complex business logic
* Conditions and branching
* Visual workflows
* Granular control
**Features:**
* Drag-and-drop interface
* Multiple node types
* Conditions and delays
* Integrated testing
### Specialized Agents
**Specific and structured tasks**
Inspired by CrewAI, allows assigning specific tasks to agents with structured prompts and well-defined expected outputs.
**When to use:**
* Well-defined tasks
* Single responsibility
* Structured output
* Agent specialization
**Features:**
* One task per agent
* Structured prompt
* Defined expected output
* Automatic validation
## Quick Comparison
| Type | Complexity | Use Cases | Execution | Configuration |
| -------------- | ---------- | -------------------- | ------------------ | --------------- |
| **LLM Agent** | Low | Chat, text analysis | Single | Simple |
| **A2A Agent** | Medium | External integration | Single | Moderate |
| **Sequential** | Medium | Linear pipelines | Sequential | Moderate |
| **Parallel** | Medium | Independent analyses | Parallel | Moderate |
| **Loop** | High | Iterative refinement | Iterative | Complex |
| **Workflow** | Very High | Complex logic | Visual/Conditional | Very Complex |
| **Task** | Low-Medium | Specific tasks | Single | Simple-Moderate |
## Selection Guide
### By Problem Complexity
**For direct tasks and conversations:**
* **LLM Agent**: Chat, text analysis, content generation
* **Task Agent**: Specific tasks with structured output
**Characteristics:**
* Quick setup
* Direct execution
* Ideal for getting started
**For processes with multiple steps:**
* **Sequential Agent**: When steps depend on each other
* **Parallel Agent**: When steps are independent
* **A2A Agent**: When you need to integrate external systems
**Characteristics:**
* Multi-agent orchestration
* Basic flow control
* Reuse of existing agents
**For sophisticated business logic:**
* **Loop Agent**: When you need to refine results iteratively
* **Workflow Agent**: When you need granular control and conditions
**Characteristics:**
* Advanced conditional logic
* Sophisticated flow control
* Detailed monitoring
### By Execution Pattern
**Agents that execute once:**
* **LLM Agent**: Direct response to a question
* **A2A Agent**: Call to external system
* **Task Agent**: Execution of specific task
**Ideal for:**
* Point queries
* Simple analyses
* Direct integrations
**Agents that execute in order:**
* **Sequential Agent**: Pipeline with dependencies
**Ideal for:**
* Data transformation
* Linear workflows
* Step-by-step processing
**Agents that execute simultaneously:**
* **Parallel Agent**: Independent analyses
**Ideal for:**
* Time optimization
* Comparative analyses
* Distributed processing
**Agents that execute in loops:**
* **Loop Agent**: Progressive refinement
**Ideal for:**
* Parameter optimization
* Iterative improvement
* Result convergence
**Agents with complex logic:**
* **Workflow Agent**: Flows with conditions and branching
**Ideal for:**
* Complex business logic
* Conditional decisions
* Visual workflows
## Use Case Examples
### E-commerce
**Scenario:** Complete product analysis for optimization
**Recommended solution:** **Parallel Agent**
* Price analysis (specialized sub-agent)
* Review analysis (sentiment sub-agent)
* Specification analysis (technical sub-agent)
* Competition analysis (market sub-agent)
**Why Parallel?** Independent analyses that can be executed simultaneously to optimize time.
**Scenario:** Sales lead qualification pipeline
**Recommended solution:** **Sequential Agent**
* Data enrichment (public data)
* Lead scoring (scoring algorithm)
* Priority classification (high/medium/low)
* Salesperson routing (based on specialization)
**Why Sequential?** Each step depends on the previous one to function correctly.
### Content and Marketing
**Scenario:** Optimized blog article generation
**Recommended solution:** **Loop Agent**
* Initial content generation
* SEO analysis and optimization
* Quality and readability review
* Refinement based on feedback
**Why Loop?** Iterative improvement until reaching desired quality.
**Scenario:** Campaign performance report
**Recommended solution:** **Task Agent**
* Specific task: generate metrics report
* Input: campaign data
* Output: structured report with insights
**Why Task?** Well-defined task with specific structured output.
### Customer Service
**Scenario:** Support system with escalation
**Recommended solution:** **Workflow Agent**
* Initial request classification
* Automatic resolution attempt
* Condition: resolved? → End : Escalation
* Routing to specialized human agent
**Why Workflow?** Complex conditional logic with multiple paths.
**Scenario:** Simple chat for frequent questions
**Recommended solution:** **LLM Agent**
* Direct conversation with customer
* Integrated knowledge base
* Contextual responses
**Why LLM?** Direct and simple interaction, no need for orchestration.
## Output Keys - State Sharing
**New Feature**: All agent types now support **Output Key** for state sharing between agents and processes.
### What are Output Keys?
The **Output Key** is a field available in all agent types that allows saving the execution result in a specific variable in the shared state. This facilitates communication between agents and building complex systems.
**Saves model response**
The response generated by the LLM is saved in the specified variable, allowing other agents to access the generated content.
```markdown theme={null}
Output Key: "analysis_response"
→ state.analysis_response
```
**Saves task result**
The structured result of the task is saved in the variable, allowing use in subsequent tasks or workflows.
```markdown theme={null}
Output Key: "processed_data"
→ state.processed_data
```
**Saves external response**
The response from the external system via A2A protocol is saved in the variable, enabling integration with other agents.
```markdown theme={null}
Output Key: "external_result"
→ state.external_result
```
**Saves workflow result**
The final result of the workflow (Sequential, Parallel, Loop, Workflow) is saved in the specified variable.
```markdown theme={null}
Output Key: "workflow_result"
→ state.workflow_result
```
### How to Use
**In the platform interface:**
1. **Configure the Output Key** in any agent
2. **Use a descriptive name** in snake\_case
3. **The result is saved automatically** in the state
4. **Other agents access** via placeholders `{{output_key_name}}`
**Example:**
```markdown theme={null}
Agent 1 - Output Key: "initial_analysis"
Agent 2 - Instructions: "Analyze the request: {{user_input}} and base it on the analysis: {{initial_analysis}}"
```
**How data flows between agents:**
```markdown theme={null}
Initial state:
{
"user_input": "Analyze this product"
}
After Agent 1 (output_key: "analysis"):
{
"user_input": "Analyze this product",
"analysis": "High quality product..."
}
After Agent 2 (output_key: "recommendation"):
{
"user_input": "Analyze this product",
"analysis": "High quality product...",
"recommendation": "I recommend the purchase because..."
}
```
**Tips for using Output Keys effectively:**
* **Clear naming**: Use names that describe the content
* **Snake\_case**: `analysis_result`, `processed_data`
* **Be specific**: `sentiment_analysis_reviews` instead of `analysis`
* **Document format**: Explain expected structure in instructions
* **Avoid conflicts**: Don't use names already existing in state
* **Consider hierarchy**: Use prefixes to group related data
## Agent Management
### Export and Import
**Backup and sharing functionality:**
In the agent listing, you can **export any agent** to a JSON file that contains the complete configuration:
**What is exported:**
* ✅ **Complete configurations** of the main agent
* ✅ **Sub-agents included** automatically in the same file
* ✅ **All dependencies** and nested configurations
* ✅ **Hierarchical structure** preserved
* ✅ **Tools and integrations** configured
**How to export:**
1. In the agent list, locate the desired agent
2. Click on the **actions menu** (⋯) of the agent
3. Select **"Export"**
4. JSON file will be downloaded automatically
**Example of exported structure:**
```json theme={null}
{
"name": "copywriter",
"description": "Creative writer specialized in innovative copywriting.",
"role": null,
"goal": null,
"type": "llm",
"model": "openai/gpt-4.1-nano",
"instruction": "You are a senior copywriter with absolute mastery of persuasion techniques",
"config": {
"output_key": "new_copy",
"tools": null,
"custom_tools": null,
"mcp_servers": null,
"custom_mcp_servers": null,
"agent_tools": null,
"sub_agents": null,
"workflow": null
},
"id": "7fd77e46-dfcb-40a2-b71f-d2bac56956ac"
}
```
**Restoring complete configurations:**
**How to import:**
1. In the agent list, click **"Import Agent"**
2. **Select the JSON file** exported previously
3. **System validates** structure and dependencies
4. **Main agent and sub-agents** are created automatically
5. **Configurations applied** exactly as exported
**Import advantages:**
* 🚀 **Instant setup** of complex agents
* 🎯 **Exact replication** of tested configurations
* 👥 **Sharing** between teams
* 🔄 **Backup and restore** of configurations
* 📦 **Migration** between environments
**Automatic validations:**
* JSON structure verification
* Agent type validation
* Dependency checking
* Available model confirmation
* Required permissions verification
**Use cases:**
```
✅ Backup of critical agents
✅ Replication in production environment
✅ Template sharing
✅ Migration between organizations
✅ Configuration versioning
```
### Folder System
**Hierarchical organization:**
The folder system allows organizing your agents hierarchically and collaboratively:
**Main features:**
* 📁 **Visual organization** of agents
* 👥 **Sharing** with other users
* 🔐 **Permission control** (view/edit)
* 🏷️ **Categorization** by project, client, or function
* 🔍 **Search within** specific folders
**How to create folders:**
1. In the agents screen, click **"New Folder"**
2. **Folder name**: Use descriptive name
3. **Description**: Summary of folder content
4. **Access settings**: Define who can access
5. Click **"Create"** to create
**Organization examples:**
```
📁 Sales
├── 🤖 lead_qualifier
├── 🤖 product_demo
└── 🤖 closer_specialist
📁 Technical Support
├── 🤖 troubleshooter
├── 🤖 documentation_helper
└── 🤖 escalation_manager
📁 Marketing
├── 🤖 content_creator
├── 🤖 social_media_manager
└── 🤖 campaign_analyzer
```
**Collaboration between users:**
**How to share a folder:**
1. **Access the folder** you want to share
2. Click the **"Share"** icon (👥)
3. **Sharing form** will open
**Configuring permissions:**
1. **Enter the email** of the Evo AI user
2. **Select access level:**
* **👁️ Viewer**: Can see and use agents, but not edit
* **✏️ Editor**: Can see, use, edit and create new agents in the folder
3. **Add optional message** explaining the sharing
4. Click **"Share"** to send invitation
**Permission levels:**
**Viewer:**
```
✅ View list of agents in folder
✅ Use agents in conversations
✅ View configurations (read-only)
❌ Edit agent configurations
❌ Create new agents
❌ Delete agents
❌ Share folder with others
```
**Editor:**
```
✅ All Viewer permissions
✅ Edit agent configurations
✅ Create new agents in folder
✅ Delete agents (that they created)
✅ Move agents between folders
❌ Share folder with others (owner only)
❌ Delete the folder
```
**Use cases for sharing:**
**By department:**
```
📁 "Company ABC Sales" Folder
Shared with: sales-team@company.com
Permission: Editor
Use: Entire team can create/edit sales agents
```
**By project:**
```
📁 "Client XYZ Project" Folder
Shared with: project-manager@company.com
Permission: Viewer
Use: Manager monitors project agents
```
**By specialty:**
```
📁 "Technical AI Agents" Folder
Shared with: ai-team@company.com
Permission: Editor
Use: Technical team develops specialized agents
```
**For clients:**
```
📁 "Final Client Agents" Folder
Shared with: client@clientcompany.com
Permission: Viewer
Use: Client tests developed agents
```
**Collaboration advantages:**
* 🤝 **Teamwork** facilitated
* 🔄 **Automatic synchronization** of updates
* 📊 **Visibility** of team work
* 🎯 **Specialization** by area/project
* 📈 **Development scalability**
* 🔐 **Granular access** control
**Managing permissions:**
**As folder owner, you can:**
* ✅ **View all users** with access
* ✅ **Change permissions** of any user
* ✅ **Remove access** from specific users
* ✅ **Transfer ownership** of folder
* ✅ **Delete folder** (removes everyone's access)
**Automatic notifications:**
* 📧 **Invitation email** when folder is shared
* 🔔 **Notification** when agent is modified by another user
* 📊 **Activity report** of shared folder
**Audit and control:**
* 📝 **Activity log** of all users
* 👤 **Modification history** with responsible party
* ⏰ **Timestamps** of all actions
* 🔍 **Complete traceability** of changes
**Best practices:**
* Use **Viewer** permission by default
* Grant **Editor** only when necessary
* **Document the purpose** of folder in name/description
* **Review permissions** periodically
* **Remove access** from inactive users
***
**Tip:** Always start with the simplest type that meets your use case. You can evolve to more complex types as your needs grow.
## Next Steps
Ideal for beginners - create your first conversational agent
For complex cases - build advanced visual workflows
Understand the protocol for integration with external systems
Set up your first agent in less than 2 minutes