Some links in this article are affiliate links. We earn a commission at no extra cost to you when you purchase through them. Full disclosure.

Building an AI agent locally is the easy part. Deploying it so it runs reliably, handles concurrent users, stays within budget, and doesn’t break at 3 AM — that’s where most teams struggle.

AI agents have different infrastructure requirements than traditional web apps. They make long-running API calls (30+ seconds), stream responses, maintain conversation state, and can burn through API budgets fast. Here’s how to deploy them properly.

Choosing a platform

Platform	Best for	Long-running	WebSockets	GPU	Starting price
Railway	Long-running agents, simplest setup	✅ No timeout	✅	❌	$5/mo
Vercel	Next.js agents, fastest DX	⚠️ 5min (Pro)	✅	❌	Free tier
Cloudflare	Edge agents, sandboxed execution	✅ Containers	✅	❌	Pay-per-use
AWS Lambda	Scale-to-zero, cheapest at scale	⚠️ 15min max	❌	❌	Pay-per-invocation
RunPod	GPU agents (local models)	✅	✅	✅	$0.20/hr
Self-hosted VPS	Full control, fixed cost	✅	✅	Optional	$5-20/mo

The timeout problem

Most AI agent interactions take 10-60 seconds. Some complex tasks (multi-step reasoning, code generation with testing) can take minutes. This eliminates platforms with short timeouts:

• Vercel Free: 10-second function timeout (too short for most agents)
• Vercel Pro: 5-minute timeout (works for simple agents)
• AWS Lambda: 15-minute max (works for most agents)
• Railway: No timeout (ideal for long-running agents)
• Self-hosted: No timeout (you control everything)

Deploying on Railway

Railway is the simplest option for AI agents. No timeout limits, built-in WebSocket support, and one-click deploys from GitHub.

# Dockerfile for a Python AI agent
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "agent_server.py"]

# agent_server.py
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from agents import Agent, Runner

app = FastAPI()
agent = Agent(name="Assistant", instructions="Help users with coding questions.")

@app.post("/chat")
async def chat(message: str):
    async def stream():
        async for event in Runner.run_streamed(agent, message):
            if hasattr(event, 'text'):
                yield f"data: {event.text}\n\n"
    return StreamingResponse(stream(), media_type="text/event-stream")

Deploy:

railway login
railway init
railway up

Railway handles SSL, domains, scaling, and logs. Your agent is live in under 5 minutes.

Deploying on Vercel

Vercel works best for Next.js-based agent UIs using the Vercel AI SDK:

// app/api/agent/route.ts
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

export async function POST(req: Request) {
  const { messages } = await req.json();
  
  const result = streamText({
    model: openai('gpt-4o'),
    system: 'You are a helpful coding assistant.',
    messages,
    tools: {
      // Your agent tools here
    },
    maxSteps: 10, // Allow multi-step agent loops
  });

  return result.toDataStreamResponse();
}

Vercel’s advantage: 30% of apps on Vercel are now deployed by AI agents (per their CEO). The platform is optimized for this workload.

Self-hosted deployment

For full control — like we use for the AI Startup Race — a VPS with Docker:

# docker-compose.yml
services:
  agent:
    build: .
    ports:
      - "8080:8080"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - DATABASE_URL=postgres://agent:pass@db:5432/agent
    restart: unless-stopped
    
  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=agent
      - POSTGRES_USER=agent
      - POSTGRES_PASSWORD=pass

volumes:
  pgdata:

Cost: $5-20/month on Vultr, Contabo, or Hetzner. Contabo is the budget king — their VPS plans start at ~$5/month with more RAM than competitors at the same price. You get full control over the environment, no timeout limits, and predictable pricing.

Production essentials

State management

Agents need to remember conversation context. Options:

Approach	Persistence	Speed	Complexity
In-memory	Session only	Fastest	Simplest
SQLite	Disk	Fast	Low
PostgreSQL	Durable	Good	Medium
Redis	Configurable	Fastest	Medium

For production, use PostgreSQL or Redis. In-memory state is lost on restart — your users lose their conversation history.

Cost controls

AI agents can burn through API budgets fast. Implement guardrails:

# Track token usage per user
MAX_TOKENS_PER_USER_PER_DAY = 100_000

async def check_budget(user_id: str) -> bool:
    usage = await get_daily_usage(user_id)
    return usage < MAX_TOKENS_PER_USER_PER_DAY

See our AI API spending guide for detailed cost management strategies.

Monitoring

At minimum, track:

• Response latency (p50, p95, p99)
• Error rate (failed agent runs / total runs)
• Token usage (per user, per agent, per day)
• Cost (actual API spend vs budget)
• Tool call success rate (are tools working?)

Connect to your observability stack — Helicone, Langfuse, or OpenTelemetry.

Health checks

@app.get("/health")
async def health():
    # Check database
    db_ok = await check_db_connection()
    # Check API key validity
    api_ok = await check_openai_key()
    
    if db_ok and api_ok:
        return {"status": "healthy"}
    return JSONResponse(status_code=503, content={"status": "unhealthy"})

Use UptimeRobot to monitor your health endpoint and get alerts when your agent goes down.

Security

• Never expose API keys in client-side code
• Rate limit per user and per IP
• Validate all user inputs before passing to the agent
• Use guardrails to prevent prompt injection
• Log all agent actions for audit trails
• Sandbox any code execution (Cloudflare or Docker)

Deployment checklist

• Choose platform based on timeout and scaling needs
• Set up persistent state (PostgreSQL/Redis)
• Implement per-user token budgets
• Add health check endpoint
• Configure monitoring and alerting
• Set up error handling and retries
• Add rate limiting
• Test with concurrent users
• Set up CI/CD for automated deploys
• Document your agent’s API for consumers

See our full AI app deployment checklist for a comprehensive pre-launch guide.

Related: OpenAI Agents SDK Guide · Cloudflare Sandbox for AI Agents · AI App Deployment Checklist · Best Hosting for AI Projects · Monitor AI API Spending · LLM Observability · AI Agent Security