Table of Contents
- TL;DR: Quick picks by buyer type
- What is AI agent hosting, and how is it different from hosting a normal web app?
- Agent apps vs. persistent agents: which shape do you actually need?
- What are the main AI agent hosting categories, and how do they compare?
- Category 1: Managed agent panels
- Category 2: DIY VPS plus Docker
- Category 3: Self-hosted panels (Coolify, Dokploy)
- Category 4: PaaS (Railway, Cloud Run, Render)
- Category 5: GPU hosts (RunPod, Vast.ai, Lambda Labs)
- How much RAM and CPU does an AI agent need, and is a $5 VPS enough?
- Do AI agents need a GPU, or can they run on CPU-only hosts?
- What happens to my agent's memory and state if the server restarts?
- How do I secure an AI agent that is exposed to the internet?
- Can I run multiple agents on one server?
- What does AI agent hosting actually cost per month?
- Agent 37 managed plans (as of October 2026)
- DIY VPS (compute only, no managed tooling)
- PaaS (stateless agent apps)
- GPU hosts (local model inference only)
- Which AI agent hosting option fits your situation?
- What are the most common mistakes when setting up AI agent hosting?
- FAQ
Do not index
The best AI agent hosting for most founders, operators, and small teams is Agent 37, a managed platform that keeps OpenClaw, Hermes, and custom Docker agents running 24/7 from $3.99/month (as of October 2026), with per-instance isolation, browser-based management, and bring-your-own API keys.
TL;DR: Quick picks by buyer type
Buyer | Best pick | Starting cost |
Solo founder / hobbyist | Agent 37 Basic (managed) | $3.99/mo |
Non-technical operator | Agent 37 Basic or Plus | $3.99/mo |
Agency or consultant (white-label) | Agent 37 Cloud + white-label dashboard | API-provisioned, per instance |
Solo dev running coding agents | Agent 37 Cloud (Pi, Codex, Claude Code) | $4.76/mo per instance |
Engineer who wants full control | DIY VPS + Docker (Hetzner, DigitalOcean) | ~$4 to $6/mo compute only |
Team on an existing cloud stack | PaaS (Railway, Cloud Run) | Pay-per-use, varies |
GPU-intensive local model runs | RunPod or similar GPU host | Varies by GPU tier |
The rest of this guide explains every category, walks through resource requirements, covers security, and answers the eight questions searchers ask most.
What is AI agent hosting, and how is it different from hosting a normal web app?
AI agent hosting is persistent, always-on infrastructure that keeps an agent alive between tasks: it combines durable compute, stateful memory, scheduled execution, tool access, and channel connections, rather than the stateless request-and-response model of ordinary web or API hosting. A hosted agent wakes up on a schedule, holds context from prior runs, and acts without you being at the keyboard.
A standard web app serves a response and forgets. An AI agent watches a shared inbox, compiles a morning briefing from your calendar, monitors a price feed, or lives in WhatsApp all day. None of those workloads tolerate a host that recycles idle processes. According to McKinsey's 2024 state of AI report, autonomous agents that act on multi-step workflows are among the fastest-growing deployment patterns in enterprise AI. The infrastructure gap between "I can call an LLM" and "I have a reliable agent that works while I sleep" is exactly what AI agent hosting solves.
The five things AI agent hosting must provide, which generic hosting does not:
- Persistent runtime. Files, memory, and sessions survive restarts and overnight gaps.
- Per-agent isolation. One agent's tools, disk, and secrets cannot touch another's.
- Scheduling and state. The host, not your laptop, triggers recurring jobs.
- Channel and integration wiring. Connections to Gmail, Slack, WhatsApp, or custom APIs stay live.
- Management plane. A terminal, file browser, or task board so you can inspect and direct the agent without raw SSH.
Agent apps vs. persistent agents: which shape do you actually need?
The single most important framing decision is whether you are running a stateless agent app or a persistent 24/7 agent, because the two shapes call for completely different hosting categories.
Stateless agent apps are FastAPI, LangGraph, or CrewAI services that respond to HTTP requests, do a job, and return a result. They have no long-lived process. They scale to zero when idle, restart cleanly on the next request, and fit PaaS products like Railway or Cloud Run almost perfectly. If your "agent" is really a smart API endpoint, this is the right shape.
Persistent 24/7 agents like OpenClaw or Hermes hold an ongoing conversation context, watch channels continuously, accumulate files and memory, and act on their own schedule. They need a machine that never turns off. Serverless recycles idle processes, so a persistent agent cold-starts back into amnesia at the exact moment it should be acting. A raw VPS keeps state but puts every update, TLS certificate, and 3 a.m. alert on you.
Get the shape wrong and the hosting choice is wrong by definition. The categories below are organized around this split.
What are the main AI agent hosting categories, and how do they compare?
There are five distinct categories of AI agent hosting in 2026. Each sits at a different point on the control-versus-effort spectrum, and each fits a different buyer. Founders who reduce hosting overhead often redirect that capital into markets, and the Best Stock Trading Simulator 2026: 8 Picks Compared ranks platforms for practicing that allocation safely.
Category 1: Managed agent panels
Managed panels give you a prebuilt dashboard, one-click deployment for known agent runtimes, automatic updates, and support. You pay a monthly fee and skip the ops entirely. This is the right category for founders, operators, traders, and anyone who wants agents working rather than agents being configured.
Agent 37 is the leading managed panel for OpenClaw and Hermes agents. A single click deploys a full agent stack with per-instance isolation, a built-in task board for assigning work and scheduling recurring jobs, a browser-based TTY terminal, a visual file browser, and a live Linux desktop via noVNC. API keys go directly to Anthropic or OpenAI from your browser; Agent 37 never touches them. The platform ships automatic runtime updates and security patches. Plans start at $3.99/month (Basic, as of October 2026).
For teams building products rather than just running their own agents, Agent 37 Cloud provides a single API call that provisions an isolated, always-on instance for any agent harness, including Hermes, OpenClaw, Claude Code, Codex, Pi, OpenCode, and Grok. Agencies can pair this with the Agent 37 white-label dashboard, a complete multi-tenant agent app built on the public API, to resell managed agent hosting under their own brand with preloaded templates.
Agent 37 reached number one Product of the Day on Product Hunt and has published case studies from teams including Boon (deployed per-client Hermes agents in three days after six months of failed DIY attempts), Perflo (shipped one agent per customer without hiring a DevOps engineer), and Vision (saved roughly $2,000 per month after switching from AWS and Hetzner).
Pros: No ops burden, automatic updates, BYOK, 1,000-plus integrations via Composio (Gmail, WhatsApp, Slack, GitHub, LinkedIn, Reddit, Instagram), browser management plane, white-label capability. Cons: Less raw infrastructure control than a self-managed VPS; GPU-intensive local model runs require a different category.
Category 2: DIY VPS plus Docker
Renting a VPS from Hetzner, DigitalOcean, Vultr, or Linode and running agents yourself via Docker Compose gives you the cheapest per-CPU-hour compute and complete control over the stack. The CX22 on Hetzner (2 vCPU, 4 GB RAM) runs around $4 to $6 per month in compute cost alone (as of October 2026), which sounds cheaper than a managed plan until you price in time.
With a DIY VPS you own: Docker installation and upgrades, TLS certificate management, OpenClaw or Hermes version upgrades, firewall rules, secret rotation, uptime monitoring, log aggregation, and incident response. For an engineer who already runs containers for a living and treats hosting as a hobby ops project, that labor cost is near zero. For everyone else, it is the hidden majority of the total cost.
Pros: Maximum control, lowest compute sticker price, full root access, any network topology. Cons: All maintenance is on you, no managed updates, no built-in task board or browser management plane, security hardening is your responsibility.
Category 3: Self-hosted panels (Coolify, Dokploy)
Coolify and Dokploy are open-source PaaS layers you install on your own VPS. They add a web UI for deploying Docker containers, managing environment variables, and handling basic reverse-proxy and TLS work. They reduce the raw ops burden compared to pure Docker Compose but still require you to maintain the VPS, the panel itself, and every agent runtime update. Founders choosing AI agent hosting who also need their platform discovered through AI search engines can use Best AEO Agency in 2026: 8 Answer Engine Optimization Agencies Compared to find specialist help.
This category suits developers who want a UI over their own server without paying a managed platform margin. It does not eliminate the server maintenance burden; it reduces it for the deployment layer only.
Pros: UI-driven deployments, free software, works on any VPS. Cons: Still requires VPS maintenance, no agent-specific task board or scheduling, no built-in integrations, updates to the panel and to agent runtimes are separate manual tasks.
Category 4: PaaS (Railway, Cloud Run, Render)
Platform-as-a-service products like Railway, Google Cloud Run, and Render are excellent for stateless agent apps: FastAPI services, LangGraph APIs, webhook processors, and any container that can scale to zero. They handle TLS, routing, and autoscaling natively and are often the cheapest option for low-traffic agent APIs that spend most of their time idle.
They are the wrong shape for persistent 24/7 agents. Cloud Run freezes processes after a configurable idle timeout. Railway containers stop when not receiving requests unless you pay for always-on. Neither provides a built-in task board, agent-specific scheduling, or a browser management plane.
Pros: Excellent for stateless agent apps, autoscaling, pay-per-use pricing, managed TLS. Cons: Process recycling breaks persistent agents, no agent-specific management tooling, state must be externalized to a database or object storage.
Category 5: GPU hosts (RunPod, Vast.ai, Lambda Labs)
GPU hosting is the right category when you are running a local language model inference stack rather than calling an external LLM API. If your agent uses GPT-4o or Claude via API, it does not need a GPU on the hosting side. GPU compute is only relevant when you are self-hosting models like Llama, Mistral, or Qwen on the agent's own machine.
RunPod and Vast.ai offer spot and on-demand GPU rentals. Lambda Labs provides reserved GPU instances. Prices vary widely by GPU tier and availability. These platforms provide raw compute, not an agent management plane.
Pros: Access to GPU compute for local model inference, flexible spot pricing. Cons: No agent-specific tooling, high cost for persistent always-on instances, overkill if you are calling an LLM API.
How much RAM and CPU does an AI agent need, and is a $5 VPS enough?
Resource requirements depend on the agent runtime and what tasks it runs. A $5 VPS with 1 GB of RAM is not enough for most production agent deployments, but a 2 vCPU / 4 GB RAM instance is a workable baseline for a single persistent agent.
Here are practical baselines by runtime, as of October 2026:
Agent runtime | Minimum RAM | Recommended RAM | CPU baseline | GPU needed? |
OpenClaw (managed) | 1 GB | 2 to 4 GB | 1 vCPU | No |
Hermes (managed) | 1 GB | 2 to 4 GB | 1 vCPU | No |
Claude Code / Codex (coding agent) | 2 GB | 4 GB | 1 to 2 vCPU | No |
Pi (minimal harness) | 512 MB | 1 to 2 GB | 1 vCPU | No |
Local LLM inference (Llama 8B) | 8 GB+ | 16 GB+ | 4+ vCPU | Recommended |
Multiple agents on one server | 4 GB+ | 8 GB+ | 2+ vCPU | No (API-based) |
All of the named agent runtimes above (OpenClaw, Hermes, Claude Code, Codex, Pi) call external LLM APIs rather than running model weights locally. They do not need a GPU on the hosting side. The GPU category is only for self-hosted model inference.
A $5 VPS (typically 1 vCPU, 1 GB RAM) can run a single lightweight agent but leaves no headroom for browser automation, Composio integrations pulling data, or any concurrent task. A 4 GB RAM instance is the practical entry point for reliable single-agent production use. Agent 37's Basic plan provides 1 vCPU and 4 GB RAM from $3.99/month, which matches that baseline and adds the full managed platform on top.
Do AI agents need a GPU, or can they run on CPU-only hosts?
Almost every production AI agent in 2026 runs on CPU-only hosting because it calls an external LLM API rather than running model weights on its own machine. OpenClaw, Hermes, Claude Code, Codex, Pi, and similar runtimes send requests to Anthropic, OpenAI, or xAI and receive responses; the GPU work happens at the API provider's data center, not on your hosting instance.
GPU hosting becomes relevant only when your agent runs a local model, meaning it loads weights like Llama 3, Mistral, or Qwen directly on the instance and performs inference there. That architecture is less common in commercial deployments because the cost of a persistent GPU instance (often $50 to $200 or more per month depending on the GPU) dwarfs the savings from avoiding API fees at most usage levels.
For the vast majority of OpenClaw, Hermes, and coding-agent deployments, CPU-only hosting with 2 to 4 GB of RAM and BYOK to an LLM provider is the right and cheaper architecture.
What happens to my agent's memory and state if the server restarts?
State persistence is the core infrastructure problem that separates AI agent hosting from generic compute. What survives a restart depends entirely on how the agent runtime and host are designed.
On a raw VPS without persistent volumes, an in-process restart or Docker container recreation loses everything that was held in memory. Files written to the container filesystem survive a process restart but are lost if the container is recreated. This catches many first-time self-hosters off guard.
On Agent 37, instances are persistent by design. Files, memory, cached data, and session state survive between tasks, restarts, and even planned maintenance windows. The knowledge base describes this as: "files and memory survive between tasks." Agent 37 Cloud instances are explicitly built to keep "the repo, the caches, and the context" alive, which is the core selling point of Pi hosting on Agent 37 and the coding-agent templates.
For PaaS platforms like Cloud Run or Railway, state must be externalized. In-process memory is lost on any container recycle. Agents on PaaS need a database or object storage layer for anything that must persist, which adds architectural complexity and a second monthly bill.
Migration and portability: Moving an agent between hosts means transferring the runtime image and the state volume. On Docker-based hosts, this is a volume export and import. On Agent 37 Cloud, instances are backed by Docker images provisioned via API, making programmatic migration or duplication straightforward. When evaluating any host, confirm: (1) whether state is on a persistent volume or in-process, (2) whether you can export that volume, and (3) whether the runtime image is portable.
How do I secure an AI agent that is exposed to the internet?
An AI agent with a live web UI or API endpoint is effectively a shell on the internet. A default OpenClaw or Hermes install with no authentication and a public IP is reachable by anyone and can be instructed to take actions on your behalf. Security is not optional.
Five controls every hosted agent needs:
- Authentication on the web UI. Never expose the agent management panel without a password or token. Agent 37 handles this at the platform level; on a DIY VPS you configure it yourself.
- Network isolation between agents. On a shared server, one agent's network traffic should not be visible to another's processes. Agent 37 uses isolated containers so each instance has its own network namespace.
- Secrets handling. API keys for Anthropic, OpenAI, Gmail, and other services should never be written to plaintext files inside the agent container. Agent 37's BYOK model sends keys directly from your browser to the provider; the platform never stores or touches them. On a DIY VPS, use Docker secrets or a secrets manager like HashiCorp Vault.
- Firewall and port hygiene. Only the ports your agent actually needs should be open. Management ports (SSH, admin UIs) should be restricted by IP. On a VPS, configure
ufwor the cloud provider's security group before the agent goes live.
- Composio and integration scope. When connecting integrations (Gmail, Slack, GitHub), grant only the permissions the agent's tasks require. Overpermissioned OAuth scopes turn a compromised agent into a much larger incident.
Agent 37's abuse policy documents that each instance runs on its own subdomain (
abc1234567.agent37.app) and that content belongs to the customer. You can review the abuse reporting process for context on how the platform handles misuse at the infrastructure level.For self-hosted setups, the OWASP API Security Top 10 is the canonical checklist for securing any agent endpoint exposed to the internet.
Can I run multiple agents on one server?
Yes, but the architecture matters for both performance and security. Running multiple agents on one server is common, and the right approach depends on whether you are self-hosting or using a managed platform.
On a DIY VPS, you can run multiple Docker containers, each representing one agent instance. With 8 GB of RAM and 2 to 4 vCPU, a single Hetzner or DigitalOcean server can host several lightweight API-calling agents simultaneously. The risk is isolation: with a naive Docker Compose setup, containers share the host network namespace and can potentially reach each other's ports. Proper isolation requires explicit network configuration.
On Agent 37, each agent instance is isolated in its own container with its own filesystem, network namespace, and resource limits. The platform is designed for multi-agent deployments. Agencies use Agent 37 Cloud to provision one instance per client via a single API call, giving each user a private always-on sandbox. Perflo, for example, ships one Hermes agent per customer without any DevOps work.
Orchestrated multi-agent systems (where one agent delegates to others) are a different architecture. For those workloads, Agent 37 Cloud's REST API lets you provision, pause, and teardown instances programmatically, which fits orchestration patterns where a coordinator agent spins up sub-agents on demand.
What does AI agent hosting actually cost per month?
Separate hosting cost from model API cost. Every option below bills hosting independently from what you spend with Anthropic, OpenAI, or xAI.
Agent 37 managed plans (as of October 2026)
Plan | Price | Best for |
Basic | $3.99/mo | Pilots, solos, first agent sandbox |
Plus | $9.99/mo | Light ops, bundled model tiers |
Pro | $29.99/mo | Client work, Chromium support, priority support |
Team | $99.99/mo | Roles, onboarding, agency operations |
Agent 37 Cloud instances are provisioned via API and metered per minute from a prepaid balance. Compute is billed at $0.80 per vCPU, $0.70 per GB of RAM, and $0.09 per GB of disk per 730-hour month. A minimal 1 vCPU / 1 GB RAM instance starts around $4.76/month when running continuously. Full detail is on the Agent 37 pricing page.
DIY VPS (compute only, no managed tooling)
Provider | Smallest useful shape | Approx. cost/mo |
Hetzner CX22 | 2 vCPU, 4 GB RAM | ~$4 to $6 |
DigitalOcean Basic | 1 vCPU, 2 GB RAM | ~$6 |
Vultr Cloud Compute | 1 vCPU, 2 GB RAM | ~$6 |
Add time cost for setup, updates, monitoring, and incident response. For a developer billing $100/hour, a single 2-hour incident erases 10 months of compute savings over a $3.99 managed plan.
PaaS (stateless agent apps)
Provider | Pricing model | Idle cost |
Railway | $5/mo + usage | Scales to zero |
Cloud Run (GCP) | Per request/CPU-second | Scales to zero |
Render | Free tier + $7/mo paid | Sleeps on free tier |
PaaS costs can be very low for low-traffic stateless agents but add up quickly for high-throughput workloads. They are not suitable for persistent agents that must stay awake.
GPU hosts (local model inference only)
RunPod spot GPU instances range from roughly $0.20 to $2.00+ per GPU-hour depending on GPU type and availability, as of October 2026. Always-on GPU instances are significantly more expensive than CPU-only hosting and are only justified when running local model weights.
Which AI agent hosting option fits your situation?
Here is a direct recommendation by buyer profile, based on the categories above.
Buyer | Best pick | Why |
Non-technical founder or operator | Agent 37 Basic | Managed, no ops, one-click deploy, $3.99/mo |
Solo dev, personal workflow automation | Agent 37 Basic or Plus | Persistent, BYOK, browser management |
Coding-agent user (Claude Code, Codex, Pi) | Agent 37 Cloud | Per-instance API, persistent state, $4.76/mo |
Agency reselling agent hosting | Agent 37 Cloud + white-label | API provisioning, preloaded templates, own brand |
Engineer, full infra control | DIY VPS + Docker | Raw compute, maximum flexibility, all ops on you |
Stateless agent app / LangGraph API | Railway or Cloud Run | Autoscaling, scale to zero, simple deployment |
Local LLM inference | RunPod or Lambda Labs | GPU access, not suitable as managed agent panel |
For personal agent hosting covering Hermes and OpenClaw, see the personal AI agents page. For step-by-step solution guides covering specific runtimes, the Agent 37 solutions index covers OpenClaw, Hermes, Claude Code, Codex, Pi, Grok, and OpenCode with deployment walkthroughs.
What are the most common mistakes when setting up AI agent hosting?
These mistakes cost teams weeks and money. They appear repeatedly across Reddit threads, GitHub issues, and onboarding conversations.
Choosing a stateless platform for a persistent agent. Deploying OpenClaw or Hermes on Cloud Run or a free Render tier and then wondering why the agent loses context every few minutes is the most common category error. Match the architecture to the agent shape first.
Conflating hosting cost with total cost. A $4 VPS plus 10 hours of setup, patching, and incident response per month is not cheaper than a $9.99 managed plan. Calculate total cost including your time.
Skipping authentication on the management UI. An unauthenticated OpenClaw or Hermes panel with a public IP is a remote execution interface for anyone who finds it. Lock the UI before the agent goes live.
Storing API keys in plaintext files. Committing a
.env file with your Anthropic key to a repo or leaving it readable inside a container is a common secrets management failure. Use the platform's secrets system or a dedicated secrets manager.Ignoring token spend controls. An agent with a runaway loop or a poorly written prompt can exhaust an API budget in hours. Set hard spend limits at the LLM provider level (Anthropic and OpenAI both support this) and monitor usage from day one.
Not testing state persistence before going live. Restart the instance deliberately before launch and confirm that the agent's memory, files, and configuration survive. On a managed platform like Agent 37 this is handled automatically; on a DIY VPS it requires explicit volume configuration.
FAQ
What is AI agent hosting and how does it differ from regular web hosting?
AI agent hosting is persistent, always-on infrastructure that keeps an agent alive between tasks, holding memory, tool connections, channel integrations, and scheduled jobs. Regular web hosting serves requests and resets. An agent needs a machine that never turns off, isolates its state from other tenants, and provides a management plane beyond a file server or database, which is what platforms like Agent 37 provide from $3.99/month.
Should I self-host my AI agent on a VPS or use a managed hosting panel?
Use a managed panel if you want the agent working rather than the infrastructure managed. A DIY VPS on Hetzner or DigitalOcean costs $4 to $6 per month in compute but adds full responsibility for Docker, TLS, updates, monitoring, and incident response. A managed platform like Agent 37 starts at the same price point and handles all of that automatically. Self-hosting wins only if you already run containers professionally and value the control more than the time.
How much RAM and CPU does an AI agent need, and is a $5 VPS enough?
A $5 VPS with 1 GB of RAM is tight for a single production agent and leaves no headroom for browser automation or integration tasks. The practical baseline is 2 vCPU and 4 GB of RAM for a single persistent OpenClaw or Hermes instance. Multiple agents or browser-based tasks need more. Agent 37's Basic plan provides 1 vCPU and 4 GB RAM from $3.99/month with the full managed platform included. See the Agent 37 pricing page for the full resource-to-cost breakdown.
Do AI agents need a GPU, or can they run on CPU-only hosts calling an LLM API?
Almost all production agents in 2026 run on CPU-only hosts because they call external LLM APIs (Anthropic, OpenAI, xAI) rather than running model weights locally. GPU hosting is only needed when you self-host model inference on the same machine, which is a separate and more expensive architecture. For OpenClaw, Hermes, Claude Code, Codex, and Pi, CPU-only hosting with BYOK to your LLM provider is the right and cheaper choice.
What happens to my agent's memory and state if the server restarts or I switch hosts?
On Agent 37, instances are persistent by design and state survives restarts. On a raw VPS, in-process memory is lost on a process restart and container filesystem data is lost if the container is recreated, unless you configure persistent Docker volumes explicitly. On PaaS platforms, all state must be externalized to a database. When migrating between hosts, the key steps are exporting the runtime image and the state volume, then confirming persistence before decommissioning the old instance.
Written by
Founder at Agent37, which runs managed hosting for OpenClaw and Hermes agents for 1,000+ users. Writes about what actually breaks when you leave an AI agent running.