Top Cloud Infrastructures for CrewAI in 2026: AMP vs Self-Hosted vs Open Source

The comparison that does not exist

CrewAI has 100,000+ developer certifications issued. PwC, DocuSign, and Gelato run production CrewAI deployments. AWS published official Prescriptive Guidance for deploying CrewAI on Bedrock. The framework is clearly production-grade and widely adopted.

The content ecosystem does not reflect this. Search "CrewAI AMP vs self-hosted" and you find zero dedicated comparison articles. Search "CrewAI infrastructure cost" and you find community forum threads with no resolution. Search "best cloud for CrewAI" and you find the CrewAI documentation itself.

This is the guide that fills that gap. The three deployment tiers evaluated with real cost analysis, followed by an independent ranking of cloud platforms for self-managed deployments, followed by the production architecture reference you cannot find anywhere else.

---

The three deployment tiers: a decision framework before the comparison

CrewAI's three deployment paths serve genuinely different organizational profiles. Choosing the wrong one creates either unnecessary cost and complexity or inadequate capability.

CrewAI AMP Cloud: fully managed

What it is: CrewAI's hosted platform. You build and deploy crews through a web interface. CrewAI manages infrastructure, scaling, monitoring, and uptime. No server configuration required.

Who it is for:

• Organizations where the engineering team's time is better spent on agent logic than infrastructure
• Teams that need enterprise SLAs and do not want to build that capability in-house
• Organizations with compliance requirements where CrewAI's certifications satisfy auditors more easily than a custom self-hosted stack

What it costs: Consumption-based pricing not fully public. Community reports indicate:

• Development and light production: $50 to $200/month
• Active production deployments: $200 to $2,000/month
• Enterprise volume: custom pricing

What it buys beyond hosting: Built-in monitoring, crew version management, execution history, team collaboration features, and the CrewAI team's operational expertise. These are non-trivial to replicate in a self-hosted stack.

The honest trade-off: At small to medium scale, AMP costs 4 to 10x more than self-hosting. That premium is only justified if the managed features provide equivalent value in engineering time saved or if compliance requirements make AMP the path of least resistance with auditors.

---

CrewAI Factory: self-hosted enterprise

What it is: CrewAI's enterprise software package for self-managed deployments. You bring your own Kubernetes cluster or on-premises hardware. CrewAI provides the software, enterprise support, and deployment tooling.

Who it is for:

• Organizations with data sovereignty requirements that preclude hosted platforms
• Enterprises running on-premises or in private cloud environments
• Teams with existing Kubernetes expertise that want the management UI of AMP without data leaving their infrastructure

What it costs: Enterprise software licensing. Not publicly priced. Requires direct engagement with CrewAI's sales team. Compute costs are entirely your own.

The honest trade-off: Factory is the right choice for a specific profile: enterprise-scale, existing Kubernetes infrastructure, data sovereignty requirement, and engineering team skilled in Kubernetes operations. Outside that profile, it adds complexity without proportionate benefit.

---

Open-source self-hosted: the baseline

What it is: The CrewAI Python library installed on any server. No additional software from CrewAI. Full control, full responsibility, zero licensing cost.

Who it is for:

• Developers and small teams evaluating CrewAI for their use case
• Organizations comfortable with Python infrastructure management
• Teams prioritizing cost efficiency over managed features
• Production deployments below 5,000 tasks/day where a simple architecture handles the load

What it costs: Compute only. A $6 to $20/month VPS for small workloads. $50 to $200/month for production deployments at medium scale.

The honest trade-off: Everything that AMP and Factory provide (monitoring, version management, execution history, team collaboration) must be built or sourced separately. This is achievable with open-source tools (Langfuse for observability, PostgreSQL for state, Redis for queuing) but requires engineering investment.

---

Cost comparison: the numbers side by side

For a production deployment handling 2,000 agent task executions per day, each averaging 3,000 tokens (input + output across all LLM calls):

Daily token volume: 6 million tokens Monthly token volume: ~180 million tokens

Deployment approach	Infrastructure cost	LLM cost (DeepSeek V3)	LLM cost (Claude 3.5 Sonnet)	Total/month (DeepSeek)	Total/month (Claude)
AMP Cloud	~$500 (estimated, mid tier)	$34	$1,080	$534	$1,580
Factory (self-hosted K8s)	$150 to $300	$34	$1,080	$184 to $334	$1,230 to $1,380
Open-source, simple VPS	$20 to $40	$34	$1,080	$54 to $74	$1,100 to $1,120
Open-source, Kubernetes	$80 to $150	$34	$1,080	$114 to $184	$1,160 to $1,230

The LLM cost dominates at volume. At Claude 3.5 Sonnet pricing, the difference between AMP and simple VPS self-hosting ($1,580 vs $1,100) is $480/month. At DeepSeek V3 pricing, the difference ($534 vs $54) is $480/month. The same gap in absolute dollars but now a 10x relative difference.

Implication: The model choice matters more than the infrastructure choice at this scale. Switching from Claude 3.5 Sonnet to DeepSeek V3 saves $1,046/month. The infrastructure tier decision saves $0 to $480/month. Optimize models first.

---

Cloud platform comparison for open-source self-hosted deployments

AWS: Bedrock + ECS Fargate

Best for: Teams already on AWS, production deployments requiring enterprise compliance, CrewAI on Bedrock workflows

Architecture: CrewAI agents run as ECS Fargate tasks (serverless containers). AWS Bedrock provides LLM access (Claude, Llama 3, Titan). Amazon DynamoDB or RDS PostgreSQL handles crew state. SQS handles task queuing.

Why AWS published official guidance: The AWS Prescriptive Guidance for CrewAI on Bedrock (using Terraform + Lambda + Bedrock) demonstrates that AWS sees commercial demand for this deployment pattern. The official pattern is production-tested and documented.

Pricing at 2,000 tasks/day:

• ECS Fargate compute: $40 to $100/month depending on task duration and concurrency
• Bedrock LLM (Claude 3.5 Sonnet via Bedrock): ~$1,080/month at 180M tokens
• RDS PostgreSQL (db.t3.micro): $25/month
• Total: $145 to $1,200/month depending on model choice

Setup complexity: High. The Terraform reference architecture is well-documented but requires AWS expertise. Not appropriate for teams without cloud engineering experience.

Lock-in profile: High. ECS Fargate, Bedrock, DynamoDB, and SQS are all AWS-specific. Migrating to a different cloud requires rewriting infrastructure code.

When to use AWS for CrewAI: When your organization is already AWS-centric and your security team has approved AWS services. When you need Bedrock model access (Claude, Llama) with AWS's data processing agreements. When your existing compliance posture is built around AWS certifications.

---

Google Cloud: Cloud Run

Best for: GCP-native teams, workloads with variable traffic that benefit from scale-to-zero

Architecture: CrewAI agents deployed as Cloud Run containers. Vertex AI provides LLM access. Cloud SQL (PostgreSQL) for state. Pub/Sub for task queuing.

The serverless appeal: Cloud Run scales to zero between tasks, meaning you pay only for execution time. For workloads with bursty traffic (e.g., CrewAI crews triggered by user events rather than continuous processing), this is a genuine cost advantage.

The community-reported problem: Long-running CrewAI workflows frequently hit Cloud Run's default 60-minute timeout and its request concurrency model creates friction for stateful agent workflows. Community forums show significant developer effort working around Cloud Run's limitations for complex multi-step agents. Cloud Run is better suited to short-lived, stateless tasks than to long-running CrewAI pipeline orchestration.

Mitigation: Configure Cloud Run with --max-instances and --timeout 3600 (maximum). Use Cloud Tasks for workflow orchestration rather than relying on Cloud Run request handling for long jobs. Alternatively, use GKE (Google Kubernetes Engine) for production CrewAI deployments, which avoids the timeout limitations.

Pricing at 2,000 tasks/day:

• Cloud Run compute: $20 to $60/month depending on task duration
• Vertex AI LLM: $50 to $1,200/month depending on model
• Cloud SQL: $30 to $100/month
• Total: $100 to $1,360/month

When to use GCP for CrewAI: When you are already in the GCP ecosystem. When task durations are short (under 15 minutes) and Cloud Run's model fits. When you want Google's Gemini models with the lowest-latency access.

---

DigitalOcean App Platform + Managed Kubernetes

Best for: Small to mid-size teams wanting managed infrastructure without AWS/GCP complexity

Two deployment options:

App Platform (PaaS): Deploy CrewAI as a Python worker service. DigitalOcean manages the container runtime, scaling, and uptime. Managed PostgreSQL database available alongside. Pricing: $12 to $50/month for the compute component.

DigitalOcean Kubernetes (DOKS): For teams that need Kubernetes features without managing control plane infrastructure. DOKS handles the Kubernetes control plane. You manage worker nodes. $12/month per node (2 vCPU / 4GB RAM). A 3-node cluster for production redundancy: $36/month compute.

The case for DigitalOcean: Simpler than AWS and GCP for teams without deep cloud engineering expertise. The managed PostgreSQL and Redis add-ons integrate cleanly with CrewAI's state and queuing requirements. Comprehensive documentation written for developers, not cloud architects.

Pricing at 2,000 tasks/day:

• DOKS 3-node cluster: $36/month compute
• Managed PostgreSQL (Basic 1GB): $15/month
• Managed Redis (1GB): $15/month
• LLM API (DeepSeek V3): $34/month
• Total: ~$100/month

Lock-in profile: Lower than AWS. Managed Kubernetes is standard. Migrating to Hetzner k3s or another provider involves moving container images and configuration but not rewriting application code.

When to use DigitalOcean: When your team wants managed infrastructure without cloud engineering complexity. When you want a single provider for compute, database, and object storage with clean integration. When cost and operational simplicity are the primary criteria over ecosystem breadth.

---

Hetzner Cloud: maximum value self-managed

Best for: Budget-conscious teams, technical founders, deployments prioritizing cost efficiency

Architecture: CrewAI Python workers running on Hetzner VPS. Nginx reverse proxy. Self-managed PostgreSQL or Managed PostgreSQL add-on ($20/month for a managed instance from Hetzner). Redis self-hosted or UpStash managed Redis ($0 to $10/month depending on volume).

The production reference architecture on Hetzner:

Internet → Nginx (CX21, $3.59/mo) → CrewAI Workers (2x CX32, $8.98/mo each)
                                  → PostgreSQL (Hetzner Managed, $20/mo)
                                  → Redis (self-hosted on CX21, $3.59/mo)

Total infrastructure cost: ~$45/month for a 3-server production setup with load balancing and database persistence.

For teams starting simpler: A single CX32 ($8.98/month) handles CrewAI at up to 500 tasks/day with adequate performance. Add the second worker node when approaching that limit.

What you give up versus managed platforms: No control plane SLA (you manage the servers), no one-click scaling, no managed Kubernetes unless you set up k3s yourself. For teams comfortable with server administration, these are manageable trade-offs for 70 to 80% cost savings.

When to use Hetzner: When cost efficiency is the primary criterion and your team can handle server administration. The reference architecture above handles 2,000 tasks/day at $45/month infrastructure, compared to $100 to $150/month on DigitalOcean managed infrastructure, and $150 to $300/month on AWS ECS.

---

Heroku and serverless platforms: the limitations

CrewAI agents frequently appear in community discussions about Heroku and serverless deployment. The community forums contain significant frustration with both.

Heroku limitations for CrewAI:

• 30-second request timeout on hobby dyno tiers
• Dynos sleep after 30 minutes of inactivity on free/hobby plans
• Stateless architecture conflicts with CrewAI's state management model
• Professional dyno pricing ($25/month per dyno) makes it expensive relative to VPS alternatives

Lambda and Cloud Functions limitations:

• 15-minute maximum execution time (Lambda) conflicts with long-running agent workflows
• Cold starts add 1 to 3 second latency to the first task in each cold period
• Stateless execution requires external state management for every workflow step
• Cost structure (per-invocation) becomes expensive for high-volume continuous workloads

The recommendation: Use serverless platforms for triggering CrewAI runs (e.g., an API Gateway Lambda that adds a task to a queue), not for executing them. The actual CrewAI workflow execution should run on a persistent server, container service, or Kubernetes pod.

---

Production architecture reference: what a properly deployed CrewAI system looks like

This is the architecture that the official documentation and third-party guides rarely show end-to-end.

                          ┌─────────────────────────────────┐
                          │         Load Balancer            │
                          │  (nginx / AWS ALB / DO LB)       │
                          └──────────┬──────────────────────┘
                                     │
                    ┌────────────────┼────────────────┐
                    │                │                │
            ┌───────┴───────┐ ┌──────┴──────┐ ┌──────┴──────┐
            │  API Server   │ │  Worker 1   │ │  Worker 2   │
            │  (FastAPI /   │ │  (CrewAI    │ │  (CrewAI    │
            │   Express)    │ │   + tools)  │ │   + tools)  │
            └───────┬───────┘ └──────┬──────┘ └──────┬──────┘
                    │                │                │
            ┌───────┴────────────────┴────────────────┴──────┐
            │                  Redis Queue                     │
            │          (task distribution + caching)           │
            └───────────────────────┬─────────────────────────┘
                                    │
            ┌───────────────────────┴─────────────────────────┐
            │            PostgreSQL Database                    │
            │    (crew state, execution history, memory)        │
            └──────────────────────────────────────────────────┘

Crew state management in PostgreSQL:

from crewai import Crew, Agent, Task
import psycopg2
import json

class PersistentCrew:
    def __init__(self, crew_id: str, db_conn):
        self.crew_id = crew_id
        self.db = db_conn

    def save_execution(self, task_id: str, result: dict, tokens_used: int):
        self.db.execute("""
            INSERT INTO crew_executions (crew_id, task_id, result, tokens_used, created_at)
            VALUES (%s, %s, %s, %s, NOW())
        """, (self.crew_id, task_id, json.dumps(result), tokens_used))
        self.db.commit()

    def get_execution_history(self, limit: int = 50) -> list:
        cursor = self.db.execute("""
            SELECT task_id, result, tokens_used, created_at
            FROM crew_executions
            WHERE crew_id = %s
            ORDER BY created_at DESC
            LIMIT %s
        """, (self.crew_id, limit))
        return cursor.fetchall()

Task queue with Redis:

import redis
import json
from crewai import Crew

r = redis.Redis(host="localhost", port=6379, db=0)

def enqueue_crew_task(crew_id: str, task_payload: dict):
    r.lpush(f"crew_queue:{crew_id}", json.dumps(task_payload))

def worker_loop(crew: Crew, queue_name: str):
    while True:
        _, payload = r.brpop(queue_name, timeout=30)
        if payload:
            task = json.loads(payload)
            result = crew.kickoff(inputs=task["inputs"])
            # Save result, notify caller, etc.

---

Kubernetes deployment for CrewAI: when to use it and how

CrewAI Factory targets Kubernetes. Open-source CrewAI also runs cleanly on Kubernetes for teams that need its scaling and self-healing capabilities.

Minimum viable Kubernetes deployment (k3s for cost efficiency):

# crewai-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: crewai-worker
spec:
  replicas: 2
  selector:
    matchLabels:
      app: crewai-worker
  template:
    metadata:
      labels:
        app: crewai-worker
    spec:
      containers:
      - name: crewai-worker
        image: your-registry/crewai-worker:latest
        env:
        - name: ANTHROPIC_API_KEY
          valueFrom:
            secretKeyRef:
              name: llm-credentials
              key: anthropic-api-key
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: postgres-url
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: crewai-worker-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: crewai-worker
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

k3s on Hetzner (cost-optimized Kubernetes): k3s is a lightweight Kubernetes distribution that runs on modest hardware. Three Hetzner CX22 servers ($4.49/month each) running k3s provide a 3-node Kubernetes cluster for $13.47/month. This handles production CrewAI deployments with horizontal scaling at roughly 85% lower infrastructure cost than managed Kubernetes on AWS EKS.

---

The decision matrix

Organization profile	Recommended deployment	Monthly infrastructure cost
Solo developer, evaluation	Single VPS (Hetzner CX22) + open-source	$5 to $10
Small team, early production	Single VPS (Hetzner CX32 or DO $12 Droplet)	$10 to $20
Growing team, reliability required	DigitalOcean App Platform or 2-server Hetzner	$45 to $100
Mid-market, AWS-centric	AWS ECS Fargate + Bedrock	$100 to $300
Enterprise, GCP-centric	GKE + Cloud Run	$100 to $300
Enterprise, data sovereignty required	CrewAI Factory + k3s or private Kubernetes	$150 to $500
No server admin preference	CrewAI AMP Cloud	$200 to $2,000

The LLM cost column is intentionally omitted from this table: it dwarfs infrastructure costs at any meaningful volume and is the same regardless of where you host CrewAI.

---

Ready to architect your CrewAI deployment?

If you are deciding between CrewAI AMP, a managed cloud deployment, or self-hosted infrastructure, and want a concrete recommendation for your specific team size, workload, and budget, we work through these decisions with technical leads in focused working sessions.

Book a 30-minute call

---

For the broader framework comparison that covers CrewAI alongside LangGraph, OpenAI Agents SDK, and 12 others with production download data, see the AI agent frameworks comparison 2026. For cost optimization strategies that apply regardless of your deployment tier, the AI agent frugality guide covers the 25 questions that determine whether your agent stack is operating efficiently.