Skip to main content
Discover the different types of reasoning agents available in the Swarms API. The /v1/reasoning-agent/types endpoint provides information about specialized reasoning architectures designed for different problem-solving approaches.
Reasoning agents use advanced techniques like self-consistency, majority voting, and iterative refinement to improve answer quality and reliability.

​
Quick Start

  • Python
  • JavaScript
  • cURL
import requests
import json
import os
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("SWARMS_API_KEY")
BASE_URL = "https://swarms-api-285321057562.us-east1.run.app"

headers = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json"
}

def get_reasoning_agent_types():
    """Get all available reasoning agent types"""
    response = requests.get(
        f"{BASE_URL}/v1/reasoning-agent/types",
        headers=headers
    )

    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

# Get reasoning agent types
reasoning_data = get_reasoning_agent_types()
if reasoning_data:
    print("✅ Reasoning agent types retrieved successfully!")
    print(json.dumps(reasoning_data, indent=2))

​
Reasoning Agent Type Comparison

TypeDescriptionBest ForSamplesQuality Focus
reasoning-agentBasic reasoning with structured thinkingSimple reasoning tasks1Balanced
reasoning-duoTwo agents with different approachesComparative analysis2Diversity
self-consistencyMultiple samples for consistency checkingHigh-stakes decisions3-5Consistency
ireIterative refinement through multiple passesComplex problem-solvingVariableAccuracy
consistency-agentFocus on logical consistencyMathematical/logical problems3Logical rigor

​
Usage Examples

  • Basic Reasoning Agent
  • Self-Consistency Agent
  • Iterative Refinement Agent
  • Reasoning Duo
payload = {
    "agent_name": "Basic Reasoner",
    "model_name": "gpt-4o",
    "system_prompt": "You are a logical reasoning assistant.",
    "max_loops": 1,
    "swarm_type": "reasoning-agent",
    "num_samples": 1,
    "task": "Solve this logic puzzle: If all bloops are razzes and some razzes are fizzles, are all bloops fizzles?"
}

​
Advanced Configuration

  • Custom Sample Count
  • Multi-Iteration Reasoning
  • Knowledge Integration
payload = {
    "agent_name": "High Consistency Agent",
    "model_name": "gpt-4o",
    "max_loops": 1,
    "swarm_type": "self-consistency",
    "num_samples": 5,  # Higher sample count for better consistency
    "output_type": "dict",  # Return detailed analysis
    "task": "Analyze the potential risks of artificial general intelligence."
}

​
Output Types

  • Dictionary Output
  • List Output
  • Final Answer Only
# Returns structured analysis
payload = {
    "swarm_type": "self-consistency",
    "output_type": "dict",
    "task": "Analyze market trends"
}
# Output: {"analysis": "...", "confidence": 0.85, "alternatives": [...]}

​
Performance Optimization

  • Quality vs Speed
  • Cost Optimization
def optimize_reasoning_config(task_complexity, time_constraint):
    """Optimize reasoning configuration based on requirements"""

    if time_constraint == "fast":
        return {
            "swarm_type": "reasoning-agent",
            "num_samples": 1,
            "max_loops": 1,
            "model_name": "gpt-4o-mini"
        }
    elif task_complexity == "high":
        return {
            "swarm_type": "ire",
            "num_samples": 5,
            "max_loops": 3,
            "model_name": "gpt-4o"
        }
    else:  # balanced
        return {
            "swarm_type": "self-consistency",
            "num_samples": 3,
            "max_loops": 1,
            "model_name": "gpt-4o"
        }

​
Use Cases by Domain

  • Scientific Research
  • Business Strategy
  • Technical Problem Solving
payload = {
    "agent_name": "Scientific Reasoner",
    "swarm_type": "ire",
    "num_samples": 3,
    "max_loops": 4,
    "task": "Design an experiment to test the hypothesis that X causes Y."
}

​
Best Practices

​
Configuration Guidelines

  1. Task Complexity: Match reasoning type to task complexity
  2. Sample Count: Use more samples for high-stakes decisions
  3. Iteration Count: Increase iterations for complex refinement
  4. Model Selection: Choose appropriate model based on requirements

​
Quality Assurance

  1. Consistency Checking: Use self-consistency for critical decisions
  2. Diverse Perspectives: Leverage reasoning-duo for balanced analysis
  3. Iterative Improvement: Apply IRE for complex problem-solving
  4. Validation: Always validate reasoning outputs

​
Performance Considerations

  1. Resource Usage: Monitor token usage and costs
  2. Response Time: Balance quality with response speed
  3. Scalability: Consider parallel processing for multiple tasks
  4. Caching: Cache reasoning results when appropriate

​
Error Handling

  1. Fallback Logic: Implement fallback to simpler reasoning types
  2. Timeout Handling: Set appropriate timeouts for long-running tasks
  3. Result Validation: Validate reasoning outputs for correctness
  4. Logging: Log reasoning processes for debugging
⌘I