Skip to main content

​
Agent Servers Overview

Agent servers are complete orchestration engines that provide intelligent workflow generation, multi-agent coordination, and autonomous execution capabilities. Unlike simple MCP providers, agent servers offer comprehensive workflow management with advanced AI reasoning.

​
What Are Agent Servers?

Agent servers combine multiple AI agents and tools to:
  • 🧠 Generate complex workflows from natural language descriptions
  • ⚙️ Execute multi-step processes with error handling and retries
  • 🔄 Coordinate multiple agents for complex problem-solving
  • 📊 Monitor and optimize workflow performance
  • 🛡️ Provide enterprise features like authentication and auditing

​
Available Agent Servers

🤖 Google ADK

Recommended - Advanced multi-agent workflow generation with Google’s Agent Development Kit

🔧 Custom Agent Server

Build your own agent server with the Kubiya SDK

​
Agent Servers vs MCP Providers

Best for:
  • Multi-step business processes
  • Complex deployment pipelines
  • Data processing workflows
  • Enterprise automation
Features:
  • Intelligent workflow planning
  • Multi-agent coordination
  • Error handling and recovery
  • Streaming execution feedback
  • Enterprise security and compliance
Example Use Cases:
  • “Deploy my application to staging and run tests”
  • “Set up a complete CI/CD pipeline for my repository”
  • “Create a data processing workflow that handles failures gracefully”
Best for:
  • Simple tool integrations
  • AI assistant capabilities
  • IDE plugins
  • Quick automations
Features:
  • Direct AI assistant integration
  • Simple tool definitions
  • Context sharing
  • Resource access
Example Use Cases:
  • “Search my codebase for a specific pattern”
  • “Generate code snippets based on my project”
  • “Access my company’s knowledge base”

​
Architecture Comparison

​
Getting Started with Agent Servers

​
Quick Decision Guide

1

Simple automation needs?

👉 Consider MCP Providers instead
2

Complex workflow requirements?

👉 Use Agent Servers - continue below
3

Choose your implementation

  • Google ADK: Best for most use cases, production-ready
  • Custom Server: Full control, custom requirements
4

Set up your environment

Follow the specific setup guide for your chosen server type

​
Minimum Requirements

  • Python 3.10+ with virtual environment
  • API Keys: Kubiya + AI provider (Together AI, OpenAI, etc.)
  • Memory: 2GB+ for local development
  • Network: Outbound HTTPS access for AI APIs
The Google Agent Development Kit provides the most advanced workflow generation capabilities:

​
Key Features

  • Multi-step workflow decomposition
  • Context-aware task planning
  • Automatic error handling generation
  • Resource optimization
  • Sequential agent execution
  • Parallel processing capabilities
  • Dynamic agent selection
  • Cross-agent context sharing
  • Real-time streaming responses
  • Comprehensive error handling
  • Health monitoring and metrics
  • Docker deployment support
  • Hot reloading for development
  • Extensive logging and debugging
  • Visual workflow inspection
  • Easy integration with existing systems

​
Quick ADK Setup

# Install dependencies
pip install kubiya-sdk google-adk

# Set environment variables
export KUBIYA_API_KEY="your-key"
export TOGETHER_API_KEY="your-key"

# Start ADK server
python3 workflow_sdk/adk_orchestration_server.py
👉 Complete ADK Setup Guide →

​
Custom Agent Servers

Build your own agent server when you need:
  • Custom AI models or providers
  • Specialized workflow types for your domain
  • Unique security requirements
  • Custom integrations with proprietary systems

​
Basic Custom Server

from kubiya.server import OrchestrationServer
from kubiya.providers import CustomProvider

class MyCustomProvider(CustomProvider):
    async def compose(self, task: str, mode: str):
        # Your custom workflow generation logic
        workflow = await self.generate_workflow(task)
        
        if mode == "act":
            result = await self.execute_workflow(workflow)
            return result
        
        return workflow

# Create and start server
server = OrchestrationServer(provider=MyCustomProvider())
server.start(port=8001)
👉 Build Custom Agent Server →

​
Integration Examples

​
Frontend Integration

// Detect agent server capabilities
const serverResponse = await fetch('http://localhost:8001/discover');
const capabilities = await serverResponse.json();

if (capabilities.server.capabilities.orchestration) {
  // This is an agent server - can handle complex workflows
  const workflowResponse = await fetch('http://localhost:8001/compose', {
    method: 'POST',
    body: JSON.stringify({
      prompt: "Deploy my application to staging",
      mode: "act"
    })
  });
}

​
MCP Integration

# Expose agent server capabilities through MCP
@mcp.tool()
def execute_complex_workflow(description: str, mode: str = "plan"):
    """Execute a complex multi-step workflow"""
    return agent_server.compose(task=description, mode=mode)

​
Production Considerations

​
Security

  • API Authentication: Always use API keys in production
  • Rate Limiting: Implement request quotas
  • Input Validation: Sanitize all user inputs
  • Audit Logging: Track all workflow executions

​
Scalability

  • Load Balancing: Multiple server instances
  • Caching: Workflow templates and responses
  • Monitoring: Health checks and metrics
  • Resource Limits: Memory and CPU constraints

​
Reliability

  • Error Recovery: Graceful failure handling
  • Retry Logic: Automatic error recovery
  • Health Monitoring: Continuous server monitoring
  • Backup Strategies: Data persistence and recovery

​
Next Steps

🚀 Start with ADK

Get up and running with Google ADK in minutes

🔧 Build Custom Server

Create your own specialized agent server

🌐 Frontend Integration

Connect your agent server to a web interface

📚 Full Tutorial

Complete end-to-end development guide
Ready to build? Choose your agent server type above and follow the detailed setup guide!