Best AI Agent Runtimes and Hosting Platforms Compared (2026)

TL;DR: There's no single best AI agent runtime, because "runtime" covers four kinds of platform. If you want to write only the prompt and tools, shortlist a managed runtime with a built-in harness: Claude Managed Agents, OpenAI's Agents API or AgentCore harness when the model needs a Linux box, or camelRun, Cloudflare Agents or Letta when the agent lives inside your product and doesn't need a shell. If you already have an agent loop, use your cloud's bring-your-own-agent runtime (AgentCore Runtime, Google Agent Runtime, Foundry Hosted Agents) or LangSmith Deployment. Durable execution engines and sandboxes are building blocks you pair with a loop of your own.

Search for AI agent hosting and you get framework lists, sandbox vendors and cloud consoles side by side. This guide sorts about 20 platforms into four groups, judges them on nine explicit criteria, and ends with a shortlist of two or three platforms for each use case. camelRun is our product. It appears in the one group it belongs to. Entries are alphabetical within each group, so the group is the recommendation, not the order.

How to judge the best AI agent runtimes: 9 criteria

An agent is a loop: call the model, run the tools it asks for, feed back the results, repeat. A runtime is where that loop lives over time. Ask every platform the same nine questions:

1. Runs the loop. Does it run the model-and-tool loop for you (a harness), or host a loop you wrote?
2. Durable state. Do history, files and pending work survive deploys, crashes and restarts?
3. Long-running and sleeping agents. Are there session caps or idle timeouts, and do you pay while an agent waits?
4. Sandboxed execution. What can the model itself run: a Linux machine, a restricted interpreter, or nothing?
5. Triggers and channels. Can schedules, webhooks or chat apps wake the agent, or only your API?
6. Human-in-the-loop. Can a run pause for an approval and resume days later?
7. Model choice. Are you limited to one vendor's models, or can you use any provider?
8. Open source and self-hosting. Can you read the code and run it yourself?
9. Pricing model. What is the billing unit, and is idle time billed?

For the layer definitions, see agent harness vs framework vs runtime vs sandbox. For the build choices behind them, see how to build an AI agent.

The four types of AI agent hosting platforms

Quick comparison

Pricing verified October 2026; rates are in the entries below.

Group 1: Managed agent runtimes with a built-in harness

You write the prompt and tools; the platform runs the loop, keeps state and wakes the agent. The biggest split in this group is whether the model gets a Linux machine. If your agent installs packages, runs tests or drives CLIs, it needs one.

AWS Bedrock AgentCore harness

The managed AgentCore harness, generally available since June 17, 2026, turns an agent into configuration. You declare the model, tools, skills and instructions, and AgentCore supplies compute, memory, identity and observability. Each session gets a microVM with a filesystem and shell, and memories and files can persist across sessions. It's powered by the open-source Strands Agents framework and can export to Strands code.

• Models: Bedrock, OpenAI, Gemini or any LiteLLM-compatible provider, switchable mid-session. Open source: no; it runs only on AWS.
• Pricing: there's no separate harness charge. You pay for the AgentCore resources it uses (Runtime vCPU-hours and GB-hours, Memory, Gateway) plus tokens.
• Best for: AWS teams that want a hosted loop, a Linux sandbox and any model. Many separate meters make the bill harder to predict. Our camelRun vs AWS Bedrock AgentCore post maps the components.

camelRun

camelAI's hosted runtime for AI agents. You define each agent's model, instructions, tools and channels. Tools live in your own TypeScript or Python code, or behind HTTP, MCP or OpenAPI. camelRun runs the loop and keeps each agent's history and files, compacting long histories. It runs model-written JavaScript in a sandbox and wakes agents on messages, schedules, chat and GitHub channels, webhooks and human approvals. Agents are keyed by your own ids, one per customer, ticket, thread or PR. Runs have no timeout, and approvals can wait days without being billed (7 by default, up to 30).

import { Agents } from "@camelai/run";

const agents = new Agents(); // CAMELAI_API_KEY
const agent = await agents.upsert("support-triage", { instructions: "Be concise." });
console.log((await agent.run("Which tickets look urgent?")).text);
await agents.close();

• Models: any. That covers Anthropic, OpenAI, OpenRouter and Amazon Bedrock, plus any OpenAI- or Anthropic-compatible server such as vLLM or Ollama. You can switch an agent's model without losing its history. Open source: the runtime is AGPL-3.0 and the SDKs are MIT. You can self-host it with one Docker container and Postgres.
• Pricing: $0.01 per agent-hour of active run time, charged on your own model keys too, plus model usage. Sleeping agents cost only storage ($0.10 per GB-month).
• Best for: agents inside a product, one per customer or thread, whose tools are your app's APIs, at thousands of agents at once.
• Limits: the sandbox runs JavaScript only: no shell, no Python, no package installs and no network. Your tools run in your own code, so those limits don't apply to them. Agents that need a Linux box belong on a sandboxed platform. Durable history also doesn't mean exactly-once side effects. camelRun never re-sends a lost tool call: it tells the model the outcome is unknown and passes your tools an idempotency key.

Claude Managed Agents

Anthropic's pre-built, configurable agent harness, in public beta since April 8, 2026. You create an agent, an environment and a session, then exchange events over server-sent events. Sessions run in an Anthropic-managed Linux sandbox (bash, file tools, web search and fetch) or in one you host yourself. Anthropic stores history and sandbox state, handles compaction, and supports cron-scheduled runs and tool confirmations.

• Models: Claude only. Open source: no.
• Pricing: tokens plus $0.08 per session-hour, metered by the millisecond and only while a session is running. Time waiting on you or on a tool confirmation isn't counted, and there's no separate container charge. Web search costs $10 per 1,000 searches.
• Best for: Claude-standardized teams whose agents need a full Linux environment with no infrastructure to run. It's a beta API, and it isn't currently eligible for Zero Data Retention or HIPAA BAA coverage. See camelRun vs Claude Managed Agents for the head-to-head.

Cloudflare Agents SDK and Project Think

In the Agents SDK, each agent is a Durable Object with its own SQL storage, WebSocket connections, scheduled tasks and human-in-the-loop approvals. Agents hibernate when idle and wake on events. Project Think (April 15, 2026, labeled experimental) adds a harness base class, @cloudflare/think, and Fibers, which are durable invocations checkpointed in SQLite. The separate Sandbox SDK runs model-written code in Linux containers or Dynamic Workers.

• Models: Workers AI by default, or OpenAI, Anthropic, Gemini and others. Open source: the SDK is MIT, but it runs on Cloudflare.
• Pricing: the Workers Paid plan ($5/month minimum). Durable Objects cost $0.15 per million requests and $12.50 per million GB-seconds, and idle objects that are eligible to hibernate aren't billed for duration. SQLite storage is $0.20 per GB-month plus row operations. Sandboxes and tokens are billed separately.
• Best for: TypeScript teams on Workers that want many per-user agents that cost little while idle, and are willing to write more of the agent themselves.

Letta

A platform for stateful agents with long-term memory, now centered on Letta Code and a TypeScript Agents SDK, with channels such as Slack, Telegram and Discord. You can use Letta Cloud or self-host the App Server. The main code recently moved to the Letta Code repo and the v1 API server was retired, so check that any tutorial you follow is current.

• Models: you choose the LLM provider. Open source: yes (Apache-2.0).
• Pricing (Letta Cloud): a free tier with limited agents, and Pro at $20/month for up to 20 stateful agents. The API plan is $20/month plus $0.10 per active agent per month and $0.00015 per second of server-side tool execution. LLM usage is billed at token cost.
• Best for: assistants and coworker agents where memory is the product.

OpenAI Agents API

Managed access to OpenAI's Codex harness, in public beta since September 10, 2026. OpenAI runs sessions, orchestration, compaction and recovery. Agents use an OpenAI-hosted sandbox (1 vCPU/1 GB, 2 vCPU/4 GB or 4 vCPU/16 GB), one you host yourself, or a partner's. Function tools run in your code, and you follow progress through streaming or webhooks. Computer use arrived on September 29, 2026.

• Models: OpenAI models, changeable per session. Open source: the Codex harness is Apache-2.0, but the control plane is hosted.
• Pricing: the API itself has no fee. You pay for tokens, tools and hosted containers: $0.03 (1 GB), $0.12 (4 GB), $0.48 (16 GB) or $1.92 (64 GB) per 20-minute session. Eligible container sessions are billed by the minute with a 5-minute minimum.
• Best for: teams on OpenAI models that want Codex's loop with a Linux sandbox or computer use. A hosted sandbox can be deleted after an hour without either activity or keep-alives, though files in /workspace/outputs survive. Data residency is US-only, and there's no Zero Data Retention. AWS shops can also look at Bedrock Managed Agents, powered by OpenAI, in preview since September 29, 2026. More in camelRun vs OpenAI Agents API.

Google also has a config-driven Managed Agents API with a Linux sandbox. It's Pre-GA, and pricing and model support weren't published alongside it at the time of writing, so it isn't included above.

Group 2: Bring-your-own-agent runtimes

These platforms host an agent you built with any framework. They provide sessions, isolation, scaling and identity. You still own the loop, including context management, compaction and tool plumbing.

Agno AgentOS

Agno's Python framework plus AgentOS, a runtime that runs in your own cloud, with an optional hosted control plane. Models: any. Open source: yes (Apache-2.0). Pricing: free self-hosted with a local control plane. Pro is $150/month for one live AgentOS connection and three seats, and you pay for your own compute. Best for: Python teams that want agents and data to stay in their own cloud.

AWS Bedrock AgentCore Runtime

Hosts an agent built with any framework and any model. You deploy a container or code, and each session gets a dedicated microVM for up to 8 hours, ending after 15 idle minutes by default. Session state is ephemeral, so durable context goes in AgentCore Memory or your own storage. The Instances compute type (August 2026) runs agents on EC2 in your account, with sessions up to 14 days and GPUs. Open source: no. Pricing: per second for CPU and memory used, and CPU scales to zero during I/O wait. V1 costs $0.0895 per vCPU-hour plus $0.00945 per GB-hour. V2, GA since September 18, 2026 with snapshot-based cold starts, costs $0.1276 plus $0.0169. Memory, Gateway and other services are billed on top. New AWS customers get up to $200 in Free Tier credits. Best for: AWS shops with an existing agent that need microVM isolation.

Google Agent Runtime

Agent Runtime, formerly Vertex AI Agent Engine, integrates fully with ADK (Python, Go) and supports LangChain, LangGraph, AG2, LlamaIndex and CrewAI templates, or any container that meets its contract. Sessions, Memory Bank and Code Execution are built in, and Google says agents can run for up to 7 days. Models: whatever your framework calls, Gemini first. Open source: no (ADK is). Pricing: $0.085 per vCPU-hour and $0.009 per GiB-hour, rounded to the second. Idle time between turns isn't billed, and 50 vCPU-hours and 100 GiB-hours are free per account each month. Sessions and Memory Bank storage costs $0.30 per GiB-month, with additional read/write-operation charges; memory generation and embeddings also incur model charges. Best for: Google Cloud teams on ADK.

LangSmith Deployment

LangChain's agent server (formerly LangGraph Platform) deploys agents from any framework. It includes checkpoints (payloads up to 25 MB), background runs, crons, human-in-the-loop review and a memory store. You can run it in LangChain's cloud, hybrid, self-hosted on Enterprise, or as a standalone Agent Server with your own Postgres, Redis and LangSmith license. Models: any. Open source: LangGraph is MIT; the platform isn't. Pricing: Plus is $39 per seat per month with one free small deployment. Extra deployments are billed in LSUs ($1 each): 0.0675 per vCPU-hour and 0.009 per GiB-hour of runtime, plus database time. Best for: LangGraph teams that want checkpoints and human-in-the-loop review built in.

Mastra Platform

Hosting for Mastra, the TypeScript agent and workflow framework (open-source core). Pricing: Starter is free with 24 CPU-hours, then $0.35/hour. Teams is $250/month with 250 CPU-hours, then $0.25/hour. A persistent server costs $100 per project. Best for: teams already on Mastra.

Microsoft Foundry Hosted Agents

Your container (Microsoft Agent Framework, LangGraph, Semantic Kernel or custom code; Python or C#) running on Foundry Agent Service. Each session gets a VM-isolated sandbox (up to 2 vCPU/4 GiB) with a persistent $HOME and /files. Compute is released after an idle timeout of 2–60 minutes (15 by default) and restored on resume, and sessions are deleted after 30 days of inactivity. Each agent gets its own Entra ID and can publish to Teams. Models: the Foundry model catalog. Open source: no. Pricing: vCPU-hours and GiB-hours during active sessions; check Azure's pricing page for rates. Best for: Microsoft 365 and Entra shops.

Group 3: Durable execution engines you pair with a loop

These engines checkpoint each workflow step, so a crash resumes from the last completed step. They don't include a harness or a sandbox. You write the loop as steps and bring the compute, except on Trigger.dev, which runs your tasks too. Our explainer on durable AI agents contrasts this with runtimes that own the loop.

• DBOS: Postgres-backed workflows. The open-source Transact library runs wherever you have Postgres. Pro is $99/month with 1 million checkpoints. Best for Postgres teams.
• Inngest: event-driven durable functions, billed per execution (each run and each step). Free includes 50,000 executions a month, and Pro starts at $99/month with 1 million. Runs last up to 30, 90 or 366 days depending on plan. The server is source-available (SSPL). Best for serverless TypeScript.
• Restate: a durable runtime for agents and backends. The server is source-available under BSL 1.1 and free to self-host for your own apps. Get Restate Cloud pricing from the vendor.
• Temporal: an MIT-licensed server you can self-host. Temporal Cloud starts at $50 per million actions and falls to $25 at volume. Best for mission-critical, multi-language systems.
• Trigger.dev: an Apache-2.0 platform that runs TypeScript tasks on its own machines. Plans are Free, Hobby ($10) and Pro ($50) a month. Compute is billed per second (Small 1x, with 0.5 vCPU, is $0.0000338/second), plus $0.25 per 10,000 runs. There are no timeouts, and waits over 5 seconds aren't billed for compute. Best for TypeScript background agents.
• Vercel Workflows: the Apache-2.0 TypeScript Workflow SDK, which runs locally, on Postgres or on Vercel. On Vercel it costs $0.02 per 1,000 events and $0.50 per GB written and per GB-month retained, plus compute. There's no maximum run or sleep duration. Best for Next.js and AI SDK apps.

Group 4: General compute and sandboxes

This is the bring-your-own-container path. It suits you when you run Claude Code, Codex, OpenCode or the Claude Agent SDK as a process, or when you're building your own platform. You own the loop, state, queueing and multi-tenancy. See Claude Code headless in Docker and hosting the Claude Agent SDK.

• E2B: open-source sandboxes for agent code at $0.000014 per vCPU-second plus $0.0000045 per GiB-second. Hobby sessions last 1 hour; Pro ($150/month) sessions last 24 hours.
• Fly.io Sprites: persistent Linux computers for agents, with checkpoints. They cost $0.03825 per CPU-hour and $0.021875 per GB-hour, billed only while running.
• Modal: serverless containers and Sandboxes ($0.00003942 per core-second, $0.00000667 per GiB-second). Strong for Python and GPUs.
• Northflank: containers on its cloud or in your own AWS, GCP or Azure account, at $0.01667 per vCPU-hour and $0.00833 per GB-hour.
• Railway: a general app platform for an agent server or worker, billed per second (about $20 per vCPU-month and $10 per GB-month of memory) against a $5 Hobby or $20 Pro plan that includes that much usage.

Daytona, Vercel Sandbox, Blaxel and Runloop compete in the same space.

Pricing: why the numbers don't line up

Model usage is an additional cost, billed by the platform or directly by your model provider. The platform's own meters measure different things:

Pricing verified October 2026. Pricing and limits change often; check each vendor's pricing page before deciding.

An agent-hour isn't a vCPU-hour, and a session-hour that includes a sandbox isn't a bare compute hour. To compare platforms, write down your workload first: number of agents, active minutes per agent per day, waits between turns, sandbox size and tokens per run. Then price that workload on each candidate.

Which platforms should you evaluate?

Start with the category, then shortlist two or three:

• An agent inside your product for each customer, ticket or thread, with your APIs as tools: group 1, no Linux box needed. Evaluate camelRun (any model, open source, priced per active agent-hour), Cloudflare Agents (if you're on Workers and will write more yourself) and Letta (if long-term memory is the feature). See multi-tenant AI agents for the architecture.
• An agent that needs a Linux machine for code, files or browsers: group 1 with a sandbox. Evaluate Claude Managed Agents (Claude), the OpenAI Agents API (OpenAI) and AgentCore harness (any model, on AWS). camelRun isn't a fit here.
• An agent you already built, needing hosting in your cloud: group 2. Evaluate your cloud's runtime (AgentCore Runtime, Google Agent Runtime or Foundry Hosted Agents), plus LangSmith Deployment if you're on LangGraph or want to stay cloud-neutral.
• An agent that is one part of a backend process: group 3. Evaluate Temporal for multi-language, mission-critical work, Inngest or Trigger.dev for TypeScript, and DBOS if you're on Postgres.
• A coding CLI or the Claude Agent SDK run as a process: group 4. Evaluate E2B, Modal and Fly.io Sprites.
• An open source agent runtime you can self-host: camelRun or Letta if you want a built-in harness, Agno AgentOS for your own Python agents, and Temporal, Trigger.dev or DBOS as engines.

Try camelRun

camelRun is a hosted runtime for durable agents. It costs $0.01 per agent-hour of active run time plus model usage, works with any model, and you can self-host it. Read the product page or build your first agent with the quickstart. If your agent needs a shell and a Linux box, pick one of the sandboxed platforms in group 1 instead.