AI Agent Hosting Platforms — Deep Research 2026

Deep Research — April 2026 · Top 7 platforms for running lightweight, single-purpose AI agents with memory, wallet integration, and per-user isolation

Executive Summary

This research evaluates cloud platforms for deploying lightweight AI agents — one agent per user, calling external LLM APIs (not running models locally), with embedded state/memory, wallet integration (Turnkey, Dynamic, Privy), and strict security isolation. No GPU needed — the LLM provider handles inference.

The seven platforms below are ranked by fit for this specific architecture: stateful per-user agents, TypeScript-first, minimal attack surface, cost-efficient at scale (1K–100K users), with the ability to integrate crypto wallet SDKs server-side.

TL;DR: Cloudflare Durable Objects is the clear #1 for this architecture. Trigger.dev is the best complement for background jobs. Hetzner is the escape hatch if you outgrow serverless economics.

Quick Comparison Matrix

Platform	Per-User Isolation	Embedded State	Hibernate / $0 Idle	TypeScript	Self-Hostable	Free Tier	Est. Cost @ 1K Users
1. Cloudflare DO	Native (1 DO = 1 user)	SQLite per DO	Yes (WebSocket hibernate)	First-class	No	Yes (free plan)	$5–25/mo
2. Trigger.dev	Via concurrency keys	Checkpointing	Yes	First-class	Apache 2.0	$5/mo free credits	$10–50/mo
3. Fly.io	1 Machine per user (manual)	Volumes ($0.15/GB)	Yes (machine suspend)	Any runtime	No	Trial only (2h)	$30–150/mo
4. Railway	Shared process	Volumes/Postgres	App sleeping (limited)	Any runtime	No	$5 trial credit	$35–80/mo
5. Modal	Per-function sandboxing	Ephemeral	Yes (scale to zero)	Python only	No	$30/mo credits	$30–100/mo
6. Hetzner VPS	Container-level (DIY)	Full disk (NVMe)	Always-on	Any runtime	Your infra	No	€4–15/mo
7. DigitalOcean	Droplet or App Platform	Managed Postgres	Always-on	Any runtime	No	$200 credit (60 days)	$24–96/mo

1. Cloudflare Workers + Durable Objects + Agents SDK #1 — Best Fit

Stateful serverless at the edge — one Durable Object per user, embedded SQLite, hibernation, $0 when idle

Pricing

$5/mo base (Workers Paid)

Includes 10M requests, 30M CPU-ms. DO requests: $0.15/M beyond 1M included. SQLite reads: $0.001/M rows. Writes: $1/M rows. Storage: $0.75/GB-month. Hibernated DOs cost $0 in compute.

Architecture Match

One Durable Object per user = one agent with private SQLite (10GB cap). Agents SDK provides AIChatAgent class with message persistence, tool calling, MCP support, WebSocket hibernate. Single-threaded execution per DO prevents race conditions on wallet operations.

NATIVE PER-USER ISOLATION EMBEDDED SQLITE MEMORY TURNKEY API STAMP COMPATIBLE TYPESCRIPT-FIRST EDGE GLOBAL WEBSOCKET HIBERNATE

Native 1:1 user:agent isolation — each DO is a private execution environment
Embedded SQLite per DO — conversation memory, user prefs, tx history stored locally
WebSocket hibernation — $0 compute when user is idle, sub-ms wake
Single-threaded per DO — eliminates race conditions on wallet signing
AI Gateway for LLM observability/caching across providers
KV + D1 + R2 ecosystem for shared state (token allowlists, rate limits)
Free plan includes SQLite-backed DOs
Agents SDK: AIChatAgent, scheduled tasks, tool calling, MCP built-in

10GB SQLite cap per DO — sufficient for agent memory, not for analytics
No GPU access — must call external LLM APIs (fine for this architecture)
V8 isolate model: no native binaries, no filesystem — all JS/TS/WASM
Vendor lock-in: DOs don't exist elsewhere; migration = full rewrite
Observability still maturing (Workers Logs improving post-Baselime acquisition)
30-second CPU time limit per request (mitigated by Workflows for long tasks)
No self-hosting option

Verdict for Openclaw: This is already your chosen architecture and it remains the optimal choice. The 1 DO = 1 user model is purpose-built for your use case. Turnkey API stamp calls via fetch() work within the V8 isolate. Memory (conversation history, swap history) fits naturally in per-DO SQLite. The Agents SDK's AIChatAgent class eliminates boilerplate. Combined with AI Gateway for MiniMax/Gemini routing, this is as close to zero-overhead agent infra as exists in 2026.

2. Trigger.dev #2 — Best Complement

Open-source TypeScript background jobs with retries, queues, and no timeouts — ideal as an execution layer alongside CF

Pricing

Free → $10/mo

Free: $5/mo credits, 10 concurrent runs, unlimited tasks. Paid from $10/mo. Per-run: compute at $0.0000338/sec (small-1x) + $0.000025/invocation. Self-host: Apache 2.0, unlimited runs.

Architecture Match

Not a replacement for CF DOs but a powerful complement. Use for: long-running swap execution workflows, scheduled portfolio rebalancing, multi-step Turnkey wallet operations. Checkpointing means a crashed task resumes from last step. Concurrency keys enable per-user queuing.

TYPESCRIPT-FIRST OPEN SOURCE (APACHE 2.0) SELF-HOSTABLE DURABLE RETRIES NO TIMEOUTS

No execution timeouts — run tasks for minutes or hours
Checkpointing: saves state, resumes after crash (critical for swap workflows)
Concurrency keys: per-user task queuing prevents double-spend
Built-in retries with exponential backoff
Open source, self-hostable on your own infra (Hetzner, etc.)
Real-time trace view via OpenTelemetry — every step visible
TypeScript-first SDK, familiar developer ergonomics
Vercel AI SDK tool integration for agent-triggered tasks

Not a stateful agent host — no persistent per-user memory/state
No GPU compute (fine — you call external LLM APIs)
Python is second-class (HTTP triggers only)
Newer ecosystem, smaller community than Temporal/BullMQ
Self-hosting requires managing Postgres + Redis + workers
No built-in WebSocket/real-time agent communication

Verdict for Openclaw: Best used as a sidecar to your CF Durable Objects architecture. When a user requests a complex multi-step swap (approve → sign → broadcast → confirm), the DO dispatches it to Trigger.dev as a durable workflow. If any step fails, Trigger retries from the checkpoint. Self-hostable on Hetzner for $4/mo if you want to own the infra.

3. Fly.io #3 — Best VM-per-Agent

Micro VMs close to users — suspend when idle, persistent volumes, multi-region by default

Pricing

~$1.94/mo per always-on micro VM

Pay-as-you-go. Shared-CPU 256MB: ~$0.0027/hr ($1.94/mo always-on). Volumes: $0.15/GB-mo. IPv4: $2/app/mo. Egress: $0.02/GB. No free tier for new users (2h trial). Machine suspend stops compute billing.

Architecture Match

You could run 1 Fly Machine per user-agent. Each Machine has its own filesystem, can suspend/resume, and supports persistent volumes. Unlike DOs, you get a full Linux environment — run any binary, any language. But managing 10K+ Machines per user is operationally heavier than DOs.

VM-LEVEL ISOLATION SUSPEND/RESUME 30+ REGIONS PERSISTENT VOLUMES ANY RUNTIME

Full Linux VM per agent — run any binary, Node.js, Python, Rust
Machine suspend: stop compute billing when idle, resume on request
30+ global regions for low-latency deployment
Persistent volumes survive deploys/restarts
Private networking between Machines (WireGuard)
Machine reservations for 40% discount on committed usage
Mature platform, strong community, good CLI

No free tier (2-hour trial for new users)
IPv4 costs $2/app/mo — adds up fast with many apps
Volumes billed 24/7 even when Machine is suspended
Multi-region multiplies all costs
Managing 10K+ Machines per user requires custom orchestration
No built-in agent framework — you wire everything yourself
No managed database (you manage Postgres yourself or use MPG)
Egress costs compound for high-traffic or data-sync workloads

Verdict for Openclaw: Overkill for your current MVP where each agent is a lightweight TS process calling LLM APIs. A full VM per user is more isolation than needed and more operational overhead. However, Fly.io becomes interesting if you later need agents that run native binaries (e.g., a local embedding model, a browser automation tool). Keep it as a Phase 3+ option if you outgrow the V8 isolate constraints of Cloudflare.

4. Railway #4 — Fastest to Ship

Push code, get a running service — usage-based billing on your own hardware, not resold AWS

Pricing

$5/mo (Hobby) → $20/mo (Pro)

Hobby: $5/mo subscription + $5 included credit. Pro: $20/mo + $20 credit. Usage: CPU $0.000077/vCPU-sec, Memory $0.0000039/GB-sec, Volumes $0.25/GB-mo, Egress $0.05/GB. Runs on Railway's own hardware (US, EU, Asia).

Architecture Match

Good for running a single monolithic agent service that handles all users. Not per-user isolation — you'd run one Docker container with your agent code and use an external database (Railway Postgres) for per-user state. App sleeping reduces idle costs. Git-push deploys are fast.

GIT-PUSH DEPLOY USAGE-BASED MANAGED POSTGRES OWN HARDWARE APP SLEEPING

Fastest deploy experience: connect repo → running service in minutes
Managed Postgres, MySQL, Redis out of the box
Usage-based billing — pay per second of actual CPU/RAM
Runs on Railway's own hardware (not resold AWS), often cheaper
App sleeping for non-production environments
Environment management: per-service secrets and variables
Private networking between services

No per-user isolation — single shared process serves all users
No hibernation for production services (always-on containers)
Idle containers still cost (memory allocation continues 24/7)
Limited regions (4 data centers vs. Fly's 30+)
Pricing can surprise at scale — databases add $10–20/mo
No background job framework — spin up second service manually
No free tier (trial credit exhausts quickly with always-on services)
250GB max volume (sufficient but not infinite)

Verdict for Openclaw: Wrong abstraction level. Railway is great for traditional web services, but your architecture needs per-user stateful isolation, which Railway doesn't provide natively. You'd have to build your own isolation layer on top, replicating what Cloudflare DOs give you for free. Useful as a quick deploy target for auxiliary services (admin dashboard, monitoring backend) but not for the agent core.

5. Modal #5 — Best for Python/ML

Serverless Python compute — decorators as infrastructure, GPU access, scale to zero

Pricing

$30/mo free credits (Starter)

CPU: $0.0000131/core-sec base (×3.75 after region + non-preempt multipliers in US). GPU: A10G ~$1.10/hr, A100 ~$3.73/hr. Team: $250/mo + $100 credits. Sandboxes force non-preemptible pricing (3× premium). Scale to zero when idle.

Architecture Match

Python-first, not TypeScript. Great for ML pipelines but wrong ecosystem for your TS-based Telegram bot architecture. No persistent per-user state (ephemeral containers). Sandboxes exist but at 3× premium cost. Best for batch processing or inference, not conversational agents.

PYTHON-FIRST SERVERLESS GPU SCALE TO ZERO $30/MO FREE SANDBOXES

$30/mo free credits — generous for testing and prototyping
Excellent DX: Python decorators define infra (no Docker, no YAML)
GPU access from A10G to H100 — useful if you later self-host models
Scale to zero: no idle charges, per-second billing
Sandboxes for code execution isolation
GPU state checkpointing for fast warm starts
Strong for batch processing and inference workloads

Python only — TypeScript is not supported
Ephemeral containers: no persistent per-user state
Sandbox pricing at 3× premium for non-preemptible workloads
Hidden multipliers: US non-preempt = 3.75× base rate
No built-in agent framework, memory, or conversation persistence
No self-hosting option
Not designed for conversational/WebSocket agents
Storage/volumes pricing undocumented

Verdict for Openclaw: Wrong language ecosystem. Your stack is TypeScript end-to-end (Cloudflare Workers, Agents SDK, Telegram Bot API). Modal's Python-only model creates a language boundary. If you ever need to run custom ML models (e.g., fine-tuned intent classifier for trade commands), Modal becomes relevant. But for your conversational agent architecture calling external APIs, it's unnecessary overhead.

6. Hetzner Cloud VPS #6 — Best Raw Value

Bare metal value — €4/mo for 2 vCPU / 4GB RAM / 40GB NVMe / 20TB traffic. Your infra, your rules.

Pricing

€3.99–€7.99/mo (post April 2026)

CX23 (2 shared vCPU, 4GB, 40GB NVMe): €3.99/mo. CPX22 (2 vCPU, 4GB, 80GB NVMe): €7.99/mo. CCX13 (2 dedicated vCPU, 8GB, 80GB NVMe): €14.86/mo. EU includes 20TB traffic. US/SG: 1TB. Hourly billing, capped at monthly rate.

Architecture Match

Self-host anything: run Docker containers, Trigger.dev workers, OpenClaw instances, Coolify, custom agent processes. Full root access. You build the isolation layer (Docker/podman per user, or single process with DB-backed state). Best price-to-compute ratio in the market.

SELF-HOST FULL ROOT ACCESS NVMe SSD 20TB TRAFFIC (EU) HOURLY BILLING ISO 27001

Unbeatable price-to-performance: 2–3× cheaper than DigitalOcean at same specs
Full root access — run any binary, any container, any language
NVMe SSD included on all plans, 20TB bandwidth in EU
Hourly billing capped at monthly rate — no surprise overcharges
EU data residency (Germany/Finland) — ISO 27001 certified
Excellent for self-hosting Trigger.dev, Coolify, databases
ARM instances (CAX) from €4.49/mo for energy-efficient workloads
Terraform provider for IaC

No managed services — you manage everything (DB, backups, security)
No auto-scaling or hibernation — always-on VMs
No per-user isolation built-in — you architect it yourself
Ticket-only support, no live chat (can be slow on weekends)
US region only has 1TB included traffic (vs 20TB EU)
Strict account verification (1–3 business day delay for new accounts)
April 2026 price increase (up to 37% on some plans)
No agent framework, memory system, or AI-specific tooling

Verdict for Openclaw: The escape hatch. If Cloudflare's per-request pricing becomes expensive at scale (100K+ active users), a Hetzner CCX with Docker containers running your agent code could be 10× cheaper for always-active users. Also ideal for self-hosting Trigger.dev workers and your monitoring/admin stack. Consider: CF DOs for the edge agent layer + Hetzner for background processing and admin services.

7. DigitalOcean (App Platform + Gradient AI) #7 — Best Managed Middle Ground

Developer-friendly managed platform — from simple App Platform to Gradient AI agent infrastructure

Pricing

$4–$24/mo (Droplets) | App Platform varies

Basic Droplet: $4/mo (512MB). $12/mo (2GB). App Platform: usage-based from $5/mo. Managed Postgres from $15/mo. Gradient AI: serverless inference with single API key across OpenAI/Anthropic/Meta. $200 free credit for 60 days.

Architecture Match

Two paths: (1) Droplet as a VPS like Hetzner but with managed services (Postgres, Redis, monitoring). (2) Gradient AI for building/deploying agents with built-in knowledge bases and evals. More expensive than Hetzner for raw compute but easier to manage.

MANAGED POSTGRES APP PLATFORM GRADIENT AI $200 FREE CREDIT GLOBAL REGIONS

$200 free credit for 60 days — good for extended testing
Managed Postgres, Redis, object storage — less ops burden than Hetzner
Gradient AI Platform: deploy agents with eval and traceability tools
Serverless inference: single API key for OpenAI, Anthropic, Meta models
App Platform: git-push deploy similar to Railway
15+ global data center locations
Strong documentation and community
Monitoring and alerting built-in

2–3× more expensive than Hetzner for equivalent VPS specs
No per-user agent isolation (same as Railway — shared process)
No hibernation/suspend for Droplets (always billed)
Gradient AI is new (2025/2026) — less battle-tested
App Platform can be restrictive for complex deployments
No self-hosting option for managed services
Egress costs can accumulate

Verdict for Openclaw: Good as a managed alternative to Hetzner if you want Postgres/Redis without managing them. The Gradient AI platform is interesting for future experimentation but not mature enough to bet your architecture on. For your MVP, the CF DO architecture is far superior. DO becomes relevant as a secondary hosting layer for databases and admin tooling if you want managed services but don't want to pay AWS prices.

Architecture Recommendation

Key Insight: Your Architecture is Rare

Most agent hosting platforms in 2026 assume a shared-process model — one service handles all users, state lives in an external database. Your requirement (one isolated agent per user with embedded state, wallet keys never in shared memory, minimal attack surface) maps almost exclusively to Cloudflare Durable Objects.

The closest alternative would be Fly.io Machines (one VM per user with suspend), but the operational overhead of managing thousands of VMs exceeds the benefit when your agents are lightweight TS processes calling external APIs. DOs give you the same isolation model at 1/10th the operational cost.

The real decision isn't "which platform" — it's "what complements Cloudflare DOs" for the parts DOs can't handle well: long-running workflows (Trigger.dev), heavy background compute (Hetzner), and managed databases for analytics/reporting (DigitalOcean or Supabase, which you already use for auth).