Updated August 2026
The short answer: if you’re hosting an AI agent app that scales to zero between requests, a serverless PaaS like Cloud Run or Railway is the right shape. If you’re hosting a persistent agent like OpenClaw, Hermes Agent, DeepSeek Harness, or Paperclip that needs to stay awake, remember things, and run scheduled loops, you need an always-on server with SSL, a process supervisor, and backups, and a managed panel with one-click agent deployment is the fastest way there. This guide covers both, ranks the real options in each, and shows exactly why the two get confused.
Search interest in agent hosting is climbing fast this year, and it’s climbing unevenly. “openclaw hosting” alone pulls meaningful monthly search volume with a cost-per-click north of $20, while a related query, “vps for ai agents,” is small in volume but carries a CPC around $58, the kind of number that shows up when buyer intent has formed but supply hasn’t caught up yet. Meanwhile, the people actually asking where to run these things are doing it in Reddit threads like r/AI_Agents, not finding answers in ranked search results, because every listicle currently ranking for “ai agent hosting” was written for the other category.
Quick Summary / TL;DR
Too long; didn’t read?
| Your situation | Category | Best pick |
|---|---|---|
| Building an agent-powered app end users hit occasionally | Agent apps (stateless) | Cloud Run, Railway, or Northflank |
| Running OpenClaw, Hermes, DeepSeek Harness, or Paperclip 24/7 | Persistent agents (stateful) | Managed panel: xCloud |
| Comfortable in a terminal, want the lowest possible bill | Persistent agents, DIY | Hetzner or DigitalOcean VPS + Docker |
| Want a self-hosted panel instead of a SaaS one | Persistent agents, DIY | Coolify or Dokploy on your own VPS |
| Running a local model alongside the agent | Either, GPU-bound | RunPod or similar GPU cloud |
| Coordinating several agents under one budget/policy | Persistent agents, orchestration | Paperclip, managed on xCloud |
The one-line verdict: most “best AI agent hosting” content ranks for a category most agent operators don’t need. If you’re asking this question because you want to run an assistant that lives in your chat apps or a coding agent that works while you sleep, skip to the persistent-agents section below.
The Split Nobody’s SERP Explains: Agent Apps vs Persistent Agents
Two different audiences ask “how do I host an AI agent,” and they need opposite infrastructure.
Agent apps are request-scoped. A user hits an endpoint, the agent reasons, returns a response, and the container can scale to zero until the next request. This is the shape Cloud Run, Railway, Northflank, and most GPU-inference platforms are built for, and it’s genuinely the right tool for that job: you don’t pay for idle time, and cold starts of a second or two don’t matter when a human is waiting on a chat response anyway.
Persistent agents are the opposite. OpenClaw needs to stay connected to WhatsApp, Telegram, and Slack around the clock. Hermes Agent’s entire value proposition is a memory that compounds across sessions, which only works if the process keeps running between them. DeepSeek Harness ships an append-only session log meant to be resumed, forked, and replayed, and its Web UI binds to localhost by design, which means remote access needs a reverse proxy, SSL, and authentication layered on top, not a cold-start container. Paperclip coordinates multiple agents against a shared budget and task list, which requires all of them to be reachable at once, not spun up on demand.
A cold-start container is a bad home for a process that’s supposed to remember what happened five minutes ago. That mismatch is exactly why the listicles currently ranking for this keyword, built around PaaS platforms, don’t serve the audience actually searching Reddit for where to run OpenClaw.
| Requirement | Agent apps | Persistent agents |
|---|---|---|
| Uptime model | Scale to zero between requests | 24/7, always listening |
| State | Stateless or externalized | Session logs, memory, skills on disk |
| Cold starts | Fine, often invisible | Breaks scheduled loops and messaging |
| Networking | Public endpoint, request/response | Reverse proxy, SSL, auth in front of a bound UI |
| Billing shape | Per-request or per-compute-second | Flat monthly, always running |
| Right tool | Cloud Run, Railway, Northflank | Managed panel or self-managed VPS |
Persistent Agent Hosting: The Ranked Comparison
This is the category with real supply gaps and the one this guide is built to answer properly.
🥇 Managed panel: xCloud
xCloud runs one-click managed hosting for all four major persistent agents on the market: OpenClaw, Hermes Agent, DeepSeek Harness, and Paperclip, on identical infrastructure and identical pricing regardless of which you pick. That last part matters more than it sounds: switching agents later means redeploying on the same plan, not migrating hosts.
Pricing is tiered by server size rather than by agent: $9.99/month for 6GB RAM (renews at $19.99), $19.99/month for 16GB (renews at $39.99), and $29.99/month for 24GB (renews at $49.99), each with NVMe storage and 30TB bandwidth, deployed in about five minutes with SSL, a reverse proxy, process supervision, and backups included. You bring your own model provider key (Anthropic, OpenAI, OpenRouter, Moonshot AI/Kimi, with Grok and Mistral coming), and pay that provider directly rather than through a resold markup.
The category-defining feature is choice: a single comparison table on the agent hosting page breaks down what each of the four actually is (OpenClaw as the messaging-first employee, Hermes as the one that keeps notes, DeepSeek Harness as the plugin-based runtime, Paperclip as the orchestrator that supervises the other three) so the decision happens before deployment rather than after a wasted weekend, with a fuller head-to-head in the OpenClaw vs Paperclip vs Hermes comparison.
Honest cons, stated plainly: this is SaaS, not open source or free; you’re paying a managed premium over raw VPS pricing; and an independent review of the OpenClaw offering flagged that neither xCloud nor the underlying agent projects currently document spending caps, rate limits, or kill switches for autonomous agent behavior at the platform level, a real gap for anyone running an agent with financial or destructive tool access unsupervised. Paperclip’s budget and governance layer is the closer answer to that specific concern, since org-level policy is its purpose; OpenClaw and Hermes hosting alone don’t have it.
🥈 DIY VPS + Docker: Hetzner or DigitalOcean
The cheapest path by a wide margin, if your time has no price tag. A Hetzner CX22 (4GB RAM) runs under $5/month; a comparable DigitalOcean droplet with a $200 new-account credit runs free for months. Both require installing Docker, pulling the agent’s image or building from source, writing a systemd unit so it survives crashes, putting Caddy or nginx in front with SSL and authentication, and configuring a firewall that exposes only what’s needed.
Best for: engineers who are comfortable in a terminal and treat the setup time as free because they enjoy it or because they’re doing it once across many agents.
🥉 Self-hosted panel: Coolify or Dokploy
A middle path between raw Docker and a managed SaaS panel. Coolify and Dokploy are open-source, self-hosted alternatives to Heroku that you install on your own VPS and then use to deploy containerized apps, agents included, through a web UI rather than raw docker-compose files. You still own the underlying server, the SSL certificates, and the security patching, but deployment and restarts get a UI instead of a terminal.
Best for: operators who want a panel’s convenience without paying a managed SaaS markup, and who don’t mind being the one who updates the panel itself.
GPU-focused: RunPod
Relevant specifically when your persistent agent is paired with a self-hosted local model rather than a hosted API. RunPod and similar GPU cloud providers rent GPU-hours rather than flat monthly server time, which fits a local-model workload poorly matched to CPU-only hosting. Pairing this with a persistent agent means running the lightweight agent process on a cheap CPU box and pointing it at a GPU endpoint elsewhere, the same split covered in the DeepSeek R1 self-hosting guide.
Best for: anyone running a self-hosted model (DeepSeek R1, Llama, or similar) behind their agent instead of calling a hosted API.
Agent Apps: Fair Coverage of the Other Category
xCloud doesn’t compete here, and this section is deliberately honest about that, because forcing a persistent-agent panel into a stateless-app comparison would be exactly the bias that undermines an otherwise useful page.
Cloud Run (Google Cloud) is the default choice for a containerized agent endpoint that needs to scale from zero to spiky traffic without capacity planning. Pay-per-request pricing, deep GCP integration, and a mature deployment story. Best for teams already on GCP or building an agent as a product feature rather than a personal tool.
Railway and Northflank occupy similar ground: git-push deployment, scale-to-zero billing, and less GCP-specific lock-in than Cloud Run. Northflank adds multi-cloud and Kubernetes-native options for teams that need that flexibility later.
Purpose-built agent app builders (a newer category of smaller platforms) trade flexibility for speed, wiring up agent-specific tooling like tool-calling frameworks and observability out of the box. Worth evaluating if your agent is closer to a product feature than an infrastructure project, though the category is young enough that vendor lock-in risk is worth weighing against the convenience.
None of these are wrong choices, and none of them will run OpenClaw or Hermes Agent well, because that was never the job they were built for.
Resource Requirements by Agent
Verified sizing, consistent across this blog’s prior agent-specific research:
| Agent | Light API use | Heavy tool/browser use | Notes |
|---|---|---|---|
| OpenClaw | 1–2 GB RAM | 4 GB+ | Scales with number of messaging channels enabled |
| Hermes Agent | 1 GB RAM | 4 GB+ (browser automation via Camofox, v0.7+) | Memory model needs persistent disk, not just RAM |
| DeepSeek Harness | 1–2 GB RAM | 4 GB+ | Session log wants durable disk across restarts |
| Paperclip | 2 GB+ RAM | 4–8 GB+ | Scales with number of agents it’s orchestrating |
| Local model alongside any of the above | — | 16 GB+ or GPU | The model, not the agent, sets the floor |
None of the four persistent agents needs a GPU by default; all call hosted LLM APIs. A GPU only enters the picture if you’re self-hosting the model, covered separately above.
Cost Comparison: Managed vs DIY vs PaaS
| Path | Monthly hosting | Setup time | Your ongoing time |
|---|---|---|---|
| xCloud managed (6GB) | $9.99 (renews $19.99) | ~5 min | ~0, updates and patching handled |
| Hetzner + Docker, self-managed | ~$5 | 1–3 hrs | 1–3 hrs/month (patching, cert renewal, monitoring) |
| DigitalOcean + Docker, self-managed | ~$12 (or free on credit) | 1–3 hrs | 1–3 hrs/month |
| Coolify/Dokploy on a VPS | ~$5–12 + your time | 2–4 hrs (panel setup once) | 30–60 min/month (panel updates too) |
| Cloud Run (agent app) | Usage-based, often <$10 for light traffic | 30–60 min | Low, managed by GCP |
The column every comparison in this space skips is the third one. At even a modest hourly rate, an hour a month of patching and monitoring on a $5 VPS makes the “cheap” option cost more than the managed one within a few months, before counting the 3am page when a certificate silently expires.
Security: An Exposed Agent Is a Shell on the Internet
This deserves its own section because it’s the part every generic hosting comparison treats as a footnote. Every one of these four agents can execute shell commands, read and write files, or take real-world actions through connected tools. A publicly reachable instance without authentication in front of it isn’t a convenience risk, it’s a live shell available to anyone who finds the address.
The concrete rules, true across every hosting path in this guide:
- Never expose an agent’s raw port (a bound localhost UI, an unauthenticated API) directly to
0.0.0.0on the public internet. - Put a reverse proxy with SSL and its own authentication layer in front of anything reachable remotely.
- If you only need access from your own machine, an SSH tunnel is safer than any public exposure and needs none of the above.
- Firewall inbound traffic to only the ports actually in use, closing everything else by default.
- Budget-and-governance controls (what Paperclip provides at the orchestration layer) are a separate concern from network security, and worth having if an agent has financial or destructive tool access, regardless of which path you host on.
Managed panels handle the networking half of this by default; they do not handle the governance half unless the agent itself, like Paperclip, is built for it.
Migration and Portability
Every agent in this comparison keeps its meaningful state, session logs, memory files, skills, in a data directory rather than baked into a specific host. That means switching providers, or switching from DIY to managed, is realistically an afternoon: archive the data directory, provision the new host, restore, restart. None of the four lock you in at the infrastructure level, whichever path you start on.
Common Mistakes When Choosing Agent Hosting
- Reading a Cloud Run or Railway comparison and applying it to a persistent agent. The infrastructure shapes are close to opposite; a scale-to-zero platform will silently break memory and scheduled loops.
- Running a persistent agent on a $5 VPS with 1GB RAM and no swap. It’ll work until the first heavy tool call, then OOM-kill the process mid-task.
- Exposing an agent’s port without a proxy or auth “just for now.” This is the single most common way a self-hosted agent gets compromised.
- Picking the cheapest VPS without pricing your own time. A free afternoon of setup isn’t free if it happens every month for patching.
- Assuming budget controls exist by default. Unless you’re running an orchestrator built for it, like Paperclip, nothing stops an agent with API access from running up a bill unsupervised.
Frequently Asked Questions
What’s the difference between AI agent hosting and regular app hosting?
Persistent AI agents need to stay running continuously, keep state on disk across restarts, and often expose a UI that binds to localhost by design, requiring a reverse proxy and authentication for remote access. Regular web apps are typically stateless and can scale to zero between requests. The infrastructure requirements diverge enough that a host built for one performs poorly for the other.
Can I host OpenClaw and Hermes Agent on the same server?
Yes. They’re separate processes with separate ports and data directories. Budget at least 4GB RAM if both see active tool use, and supervise each independently so one crashing doesn’t affect the other. A managed platform running both on one plan, like xCloud’s 16GB or 24GB tier, removes the need to configure that separation yourself.
How much RAM does an AI agent need?
1 to 2GB covers light, API-only use for any of the four major persistent agents. Once you enable heavy tool use, browser automation, or multiple concurrent sessions, budget 4GB or more. A self-hosted local model behind the agent, rather than a hosted API, pushes requirements to 16GB or a dedicated GPU regardless of the agent layer.
Why can’t I reach my agent’s web UI from my browser?
Most commonly because the agent binds to 127.0.0.1 (localhost) by design, a security default in projects like DeepSeek Harness. Reaching it remotely requires either an SSH tunnel or a reverse proxy with SSL and authentication in front of it; opening a firewall port alone won’t fix it, and shouldn’t be done without that layer in front regardless.
Is a $5 VPS enough for an AI agent?
For light, single-agent, API-driven use, yes, if it has at least 2GB RAM. For heavy tool use, browser automation, or running more than one agent, no; you’ll hit memory pressure the first time a task needs headroom the box doesn’t have.
Do AI agents need a GPU?
No, not by default. All four major persistent agents (OpenClaw, Hermes Agent, DeepSeek Harness, Paperclip) call hosted LLM APIs, so the server only runs agent logic, which is CPU-light. A GPU becomes necessary only if you self-host the underlying model instead of calling a provider’s API.
What happens to my agent’s memory if the server restarts?
Depends entirely on whether its data directory sits on persistent, mounted disk. On a standard VPS or managed instance, restarts don’t touch persistent disk and memory survives. In Docker, the state only survives if the data directory is mounted as a named volume; without one, a container rebuild wipes it.
Should I self-host or use a managed panel?
Self-host if you’re comfortable owning security patching, certificate renewal, and 3am incident response, and if your time genuinely costs you nothing. Use a managed panel if you’d rather pay a predictable monthly fee than be on call for infrastructure that isn’t your core work. Most people who try both once end up on the managed side after the first certificate expires unexpectedly.
Can I run more than one agent for orchestration, not just side by side?
That’s specifically what Paperclip is built for: coordinating multiple agents, including OpenClaw and Claude Code, under a shared task list, budget, and governance policy, rather than running them as unrelated neighbors on one box. It’s a different use case from simply hosting two agents that don’t talk to each other.
How do I switch from one agent to another later?
On a managed platform where all agents share the same plan and pricing, like xCloud’s, switching means deploying the new agent on your existing plan rather than migrating hosts. Self-managed, it means provisioning the new agent’s runtime on your existing server or a new one and pointing your provider keys at it; the underlying VPS doesn’t need to change.
Is my data private on a managed agent hosting platform?
On a well-built managed platform, agents run on dedicated, isolated instances rather than shared infrastructure, with data encrypted in transit and in backups, and provider access limited to when you request support. Confirm this explicitly with any platform before trusting it with credentials or sensitive tool access; it isn’t universal across the category.
Conclusion: Match the Host to the Agent’s Shape
The “best AI agent hosting” question only has a clean answer once you know which of the two categories you’re actually in. An agent app that responds to requests and goes quiet belongs on a scale-to-zero platform built for exactly that. A persistent agent that needs to remember, stay connected, and run on a schedule belongs on an always-on server, and the choice inside that category comes down to how much of the operational burden, patching, certificates, backups, uptime, you want to carry yourself.
Expert Picks by Goal
| Your goal | Best choice | Why |
|---|---|---|
| One assistant across all your messaging apps | OpenClaw, managed | Purpose-built messaging gateway |
| An agent that improves with repeated use | Hermes Agent, managed | Compounding memory model |
| A runtime you can reshape at every layer | DeepSeek Harness, managed | Plugin kernel, session replay |
| Supervising several agents under one policy | Paperclip, managed | Built for orchestration and budget control |
| Lowest possible bill, comfortable in a terminal | Hetzner/DO + Docker | A few dollars a month, all the setup yourself |
| A request-scoped agent app, not a persistent one | Cloud Run or Railway | Scale-to-zero fits the workload |
| Undecided between the four agents | Compare them side by side | Same plan, same price, switch later |
What to do this week: figure out which of the two categories your project actually belongs to, that decision alone eliminates half of what’s currently ranking for this search. If you’re in the persistent-agent category, compare the four options on one plan and deploy the one that fits in about five minutes, backed by a 14-day money-back guarantee if it turns out to be the wrong pick.
For more guides on hosting AI agents and the infrastructure behind them, subscribe to the xCloud blog or join the xCloud Facebook community.
