Integrating with Existing AI Frameworks

Connect Kubiya to your existing LangGraph, LangChain, CrewAI, and other AI frameworks

Integrating with Existing AI Frameworks

Kubiya seamlessly integrates with popular AI frameworks, allowing you to enhance your existing agent systems with production-grade orchestration, execution, and scaling capabilities. Instead of replacing your current setup, Kubiya acts as an execution layer that brings deterministic workflows and enterprise features to your AI agents.

Why Integrate with Kubiya?

🚀 Production-Ready Execution

Transform your experimental AI agents into production-ready systems with containerized execution, error handling, and automatic scaling.

🔒 Enterprise Security & Compliance

Add enterprise-grade security, audit trails, and compliance features to your existing AI workflows without changing your core logic.

🌊 Streaming & Real-time Updates

Enable real-time streaming of agent execution to frontend applications using standard protocols like SSE and Vercel AI SDK.

⚖️ Deterministic & Reliable

Unlike free-roaming agent frameworks, Kubiya provides rails and boundaries that ensure predictable execution paths.

Supported Frameworks

LangGraph

Multi-agent workflows with state management

• Graph-based agent orchestration
• Stateful conversations
• Human-in-the-loop patterns
• Complex routing logic

LangChain

Chain-based agent pipelines

• Sequential processing chains
• RAG and retrieval patterns
• Tool integration
• Memory management

CrewAI

Multi-agent collaboration

• Role-based agent teams
• Collaborative task solving
• Agent coordination
• Hierarchical workflows

Custom Frameworks

Your own AI framework

• Any Python-based framework
• Custom agent implementations
• Proprietary AI systems
• Legacy integrations

Integration Patterns

There are three main patterns for integrating existing AI frameworks with Kubiya:

1. Workflow Wrapping Pattern

Wrap your existing agent code within Kubiya workflows for execution orchestration:

LangGraph Integration

from kubiya_workflow_sdk import workflow, step

@workflow
def langgraph_agent_workflow():
    # Your existing LangGraph code
    result = step("langgraph_execution").python(
        code="""
import langgraph
from your_existing_code import create_agent_graph

# Your existing LangGraph setup
graph = create_agent_graph()
result = graph.invoke({"messages": [{"role": "user", "content": "${INPUT}"}]})
return result
        """,
        requirements=["langgraph", "langchain"]
    )
    
    return result

2. Agent Server Integration

Deploy your framework as a custom agent server provider:

from kubiya_workflow_sdk.providers import BaseProvider

class LangGraphProvider(BaseProvider):
    def __init__(self):
        self.graph = self.create_langgraph_agent()
    
    async def compose(self, task: str, mode: str = "act"):
        # Your existing LangGraph logic
        result = await self.graph.ainvoke({
            "messages": [{"role": "user", "content": task}]
        })
        return result
    
    def create_langgraph_agent(self):
        # Your existing agent creation code
        from langgraph import StateGraph
        # ... your graph setup
        return compiled_graph

3. Hybrid Architecture

Combine Kubiya’s orchestration with your framework’s agent logic:

from kubiya_workflow_sdk import workflow, step

@workflow
def hybrid_ai_pipeline():
    # Use Kubiya's ADK for planning
    plan = step("planning").adk_compose(
        task="Create a plan for: ${INPUT}",
        mode="plan"
    )
    
    # Use your existing framework for execution
    execution = step("crewai_execution").python(
        code="""
from your_existing_code import execute_plan_with_crewai
result = execute_plan_with_crewai("${plan.strategy}")
return result
        """,
        requirements=["crewai"]
    ).depends("planning")
    
    # Use Kubiya for monitoring and reporting
    report = step("reporting").adk_compose(
        task="Generate report for execution: ${execution}",
        mode="act"
    ).depends("crewai_execution")

Key Integration Benefits

Scalability

Kubernetes-Native Scaling

Your existing AI agents automatically gain:

• Horizontal pod autoscaling
• Resource management and limits
• Load balancing across replicas
• Multi-zone deployments

# Your LangGraph agents now scale automatically
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: langgraph-agent-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: langgraph-agent
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Kubernetes-Native Scaling

Your existing AI agents automatically gain:

• Horizontal pod autoscaling
• Resource management and limits
• Load balancing across replicas
• Multi-zone deployments

# Your LangGraph agents now scale automatically
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: langgraph-agent-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: langgraph-agent
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Built-in Observability

Gain visibility into your AI agents:

• Execution traces and logs
• Performance metrics
• Error tracking and alerting
• Cost analysis

# Automatic tracing for your existing agents
from kubiya_workflow_sdk.observability import trace_agent

@trace_agent
def your_existing_langgraph_function():
    # Your existing code gets automatic tracing
    graph = create_agent_graph()
    return graph.invoke(input_data)

Enterprise Security Layer

Add security without code changes:

• Network policies and segmentation
• Secret management
• Audit logging
• Compliance reporting

# Automatic security policies
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: langgraph-agent-policy
spec:
  podSelector:
    matchLabels:
      app: langgraph-agent
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: kubiya-system

Migration Strategies

Gradual Migration

1. Start with Workflow Wrapping

   Begin by wrapping your existing agents in Kubiya workflows without changing core logic

2. Add Orchestration Features

   Gradually add streaming, monitoring, and error handling capabilities

3. Optimize for Production

   Refactor critical paths to use native Kubiya features for better performance

4. Full Integration

   Move to custom providers or hybrid architectures for maximum benefit

Parallel Development

1. Deploy Side by Side

   Run your existing system alongside Kubiya-integrated versions

2. A/B Testing

   Compare performance and reliability between implementations

3. Gradual Traffic Shift

   Slowly move traffic from legacy to Kubiya-integrated agents

4. Sunset Legacy

   Retire old implementation once migration is complete

Common Integration Scenarios

🔍 Research & Analysis Agents

Scenario: You have LangGraph agents doing research and analysis

Integration: Wrap in Kubiya workflows to add streaming results, automatic retries, and result caching

Benefit: Research agents become production-ready with real-time progress updates

👥 Multi-Agent Teams

Scenario: CrewAI teams handling complex business processes

Integration: Use Kubiya’s orchestration for team coordination and result aggregation

Benefit: Better coordination, fault tolerance, and scalability across agent teams

🔗 Chain-Based Processing

Scenario: LangChain pipelines for document processing or RAG

Integration: Add Kubiya’s execution layer for parallel processing and error recovery

Benefit: Faster processing through parallelization and better error handling

🤝 Human-in-the-Loop

Scenario: Agents requiring human approval or intervention

Integration: Use Kubiya’s workflow pausing and resumption capabilities

Benefit: Seamless human-AI collaboration with proper state management

Getting Started

Choose your framework and follow the specific integration guide:

LangGraph Integration

Connect stateful multi-agent graphs

LangChain Integration

Enhance chain-based workflows

CrewAI Integration

Scale multi-agent teams

Support & Community

Discord Community

Join our community for integration help and best practices

GitHub Examples

Browse real-world integration examples and templates