--- title: 'Claude Managed Agents Alternatives: 8 Options Compared (2026)' published date: '2026-10-09' author: 'Illiana Reed' title-image: 'https://camelai.com/blog/assets/images/covers/claude-managed-agents-alternatives.png' --- **TL;DR:** The right Claude Managed Agents alternative depends on why you're leaving. If the blocker is Claude-only models or Anthropic-only hosting, camelRun and Letta are the two options on this list that pair model-agnostic managed agents with an open-source runtime you can self-host end to end. AWS teams should look at AgentCore harness. If you're happy with Claude and your agent needs a full Linux machine, staying on Claude Managed Agents is usually the right call. --- ## Why teams look for Claude Managed Agents alternatives [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview) (CMA) is Anthropic's hosted agent harness: you define an agent and an environment, and Anthropic runs the loop, executes tools in a sandbox and keeps history server-side. It does that well. The reasons people look elsewhere are structural: - **Claude-only models.** Agents accept "Claude 4.5 and later models" ([agent setup](https://platform.claude.com/docs/en/managed-agents/agent-setup)). - **Beta.** Every endpoint needs the `managed-agents-2026-04-01` beta header, and behaviors may be refined between releases. - **Anthropic holds the control plane.** [Self-hosted sandboxes](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes) move tool execution to your infrastructure, but orchestration stays with Anthropic, tool inputs and outputs still flow through its control plane, and Anthropic stores skills and memory stores. - **No ZDR or HIPAA BAA.** Because sessions are stored server-side, CMA "is not currently eligible" for either. - **Billing route.** CMA isn't available as a partner-operated Bedrock or Vertex service ([pricing](https://platform.claude.com/docs/en/about-claude/pricing)). It is available separately through [Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws), with AWS billing and some feature and session differences. AWS billing alone is therefore not a reason to migrate. Price is a weaker reason: CMA charges $0.08 per session-hour, metered only while a session is `running`, plus tokens. ## How we chose the alternatives **Eligibility.** An option must (1) give you a ready-made agent loop, or a hosted runtime for a loop you write, with state kept between turns; (2) be open for sign-up today (GA, public beta or public preview); and (3) publish a pricing basis we could check on an official page. A general framework you host and wire up yourself doesn't qualify; the [three ways to build an AI agent](https://camelai.com/blog/how-to-build-an-ai-agent) covers that route. We make one exception: self-hosting Anthropic's own Claude Agent SDK, because it's the usual way teams keep Claude while leaving the managed service. **No universal ranking.** Which alternative is best depends on which limitation you're leaving behind, so the list is grouped by that reason rather than scored. Within each group, the table below gives the facts that decide it: which models you can use, whether someone runs the harness for you, whether you can self-host, where the model's code runs, and how mature the product is. Two caveats. We make camelRun, so weigh our description of it accordingly. And if your agent must run bash, install packages or execute Python, filter on the "Code execution" column first: camelRun drops out, and CMA itself may be the best fit. We don't compare compliance programs such as ZDR or HIPAA; check each vendor's terms. ## Claude Managed Agents alternatives at a glance | Option | Models | Managed harness | Open source / self-host | Code execution | Status | |---|---|---|---|---|---| | **CMA (baseline)** | Claude 4.5 and later | Yes | Closed; tools can run on your infra | Ubuntu sandbox | Public beta | | **camelRun** | Any provider, incl. your own endpoints | Yes | AGPL runtime; Docker + Postgres | JavaScript only | Available; SDKs pre-1.0 | | **Letta** | 30+ providers | Yes (Letta Cloud) | Apache-2.0; App Server | Cloud sandboxes or your machine | Available | | **AWS AgentCore** | Bedrock, OpenAI, Gemini, LiteLLM | Yes (harness) | Strands is open; service is AWS-only | microVM with shell | GA | | **Google Agent Runtime + ADK** | Gemini; others via LiteLLM | Hosts your ADK agent (Managed Agents is preview) | ADK open; platform is Google Cloud-only | Code execution sandbox | Available (Managed Agents: preview) | | **Cloudflare Agents + Think** | Any via the AI SDK | Think harness | MIT SDK; runs on Cloudflare | Dynamic Workers, containers | SDK available; Think experimental | | **LangSmith + Deep Agents** | Any | Managed Deep Agents (US-only, CLI-first) | MIT harness; self-hosted server needs a license | Sandbox per thread | Managed Deep Agents: public beta | | **OpenAI Agents API** | OpenAI | Yes (Codex harness) | Codex harness open; hosted control plane | Linux sandbox, 1–16 GB | Public beta | | **Self-hosted Claude Agent SDK** | Claude | No, you host it | Your infra; Anthropic Commercial Terms | Your container | Available | Each entry below lists its pricing basis, and the units don't line up: CMA bills per running session-hour, camelRun per active agent-hour, Letta per active agent per month, AgentCore, Google and LangSmith per vCPU-hour and GB-hour, and OpenAI per container session, with tokens on top everywhere. Anthropic's [hosting guide](https://code.claude.com/docs/en/agent-sdk/hosting) notes that tokens typically dominate container cost by an order of magnitude or more, so model your own workload before comparing. *Pricing verified October 2026. Pricing and limits change often; check each vendor's pricing page before deciding.* ## The 8 alternatives, by why you're leaving The order follows the reasons people leave CMA, not a score. ### If you want model choice and an open-source runtime #### [camelRun](https://camelai.com/run): best for model-agnostic agents inside your product **What it is:** camelAI's hosted runtime for AI agents. You define each agent's model, instructions, tools and channels. camelRun runs the loop, keeps each agent's history and files (compacting long histories), runs model-written JavaScript in a sandbox, and wakes agents for messages, schedules, Slack, Discord, Telegram or GitHub events, webhooks and human approvals. Agents are keyed by your own ids, one per customer, ticket or thread. ```ts 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(); ``` **How it differs from CMA:** Any model: Anthropic, OpenAI, OpenRouter, Amazon Bedrock, or a server that speaks OpenAI's or Anthropic's API, such as vLLM or Ollama. Switch an agent's model and it keeps its history. Tools stay in your TypeScript or Python code, or behind HTTP, MCP or OpenAPI, and camelRun makes the calls, so the model never sees your credentials. The runtime is AGPL-3.0, the SDKs are MIT, and self-hosting takes one Docker container plus Postgres. From a clone of the [repo](https://github.com/qaml-ai/run): ```sh cd deploy/selfhost cp .env.example .env # fill it in; secrets: openssl rand -hex 32 docker compose up -d curl -s localhost:8790/healthz ``` **Limits to know:** The sandbox runs JavaScript only: no shell, no Python, no package installs, no network. Agents that build and test code or run arbitrary CLIs are better served by CMA or a Linux-sandbox option below. The Python SDK lets your application run tools written in Python; it doesn't add model-written Python execution to the sandbox. Durable history isn't exactly-once side effects: camelRun never re-sends a lost tool call, tells the model the outcome is unknown, and gives your tools an idempotency key. It's also new as a public product, with pre-1.0 SDKs. **Choose it over CMA when:** you want to mix or switch model providers, keep tools and credentials in your app, run thousands of agents at once (most asleep), or keep a self-host option. camelAI moved camelCode's agents onto it and deleted about 72,000 lines of code ([intro post](https://camelai.com/blog/the-web-wasnt-built-for-agents)). **Pricing basis:** $0.01 per agent-hour of active run time, plus model usage (your keys, or list price on camelRun's). Sleeping agents cost only storage, at $0.10 per GB-month. #### [Letta](https://docs.letta.com/): best for agents built around long-term memory **What it is:** A platform for stateful agents with a memory system and continual learning. One Agent SDK runs agents on Letta Cloud, a self-hosted App Server or your own machine. Tools run locally, in cloud sandboxes or on registered computers, with MCP support and human approval for risky calls. **How it differs from CMA:** [30+ model providers](https://docs.letta.com/configuration/models), including Anthropic, OpenAI, Gemini, Bedrock, OpenRouter and Ollama, and you can change an agent's model mid-conversation. It's Apache-2.0, and the [self-hosted App Server](https://docs.letta.com/self-hosting) ships Docker, Railway and Fly.io configs plus Slack, Telegram and Discord channels. **Choose it over CMA when:** memory is the product (assistants or AI coworkers that should remember and improve over months) and you want model freedom with a self-host path. **Pricing basis:** The [API plan](https://docs.letta.com/pricing) is $20/month, plus $0.10 per active agent per month and $0.00015 per second of server-side tool CPU time, with LLM usage at the model's token cost. Client-side and remote MCP execution do not incur that tool CPU charge; web search and fetch can have separate costs. ### If you want to stay inside your cloud #### [AWS Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness.html) (harness + Runtime): best for AWS shops **What it is:** AWS's modular agent platform. The **harness** (GA since June 2026) turns an agent into configuration: declare the model, tools, skills and instructions, and AgentCore runs it in an isolated microVM per session with its own filesystem and shell, persisting memories and files across sessions. **Runtime** hosts a loop you build with any framework, and Memory, Gateway, Identity and other services are billed separately. **How it differs from CMA:** Any model from Bedrock, OpenAI, Gemini or a LiteLLM-compatible provider, switchable mid-session. The harness is powered by the open-source Strands Agents framework and exports to Strands code, but the service is AWS-only. Runtime sessions default to an 8-hour maximum and a 15-minute idle timeout, at up to 2 vCPU and 8 GB each ([quotas](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/bedrock-agentcore-limits.html)). **Choose it over CMA when:** you're standardized on AWS, need IAM and VPC controls and a real shell, and want model choice. See [camelRun vs AgentCore](https://camelai.com/blog/camelrun-vs-aws-bedrock-agentcore). **Pricing basis:** No separate harness charge; you pay for what runs underneath. Runtime V1 is $0.0895 per vCPU-hour plus $0.00945 per GB-hour, billed per second, with CPU not billed during I/O wait ([pricing](https://aws.amazon.com/bedrock/agentcore/pricing/)). #### [Google Agent Runtime](https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/runtime) + ADK: best for Google Cloud teams **What it is:** Agent Runtime, formerly Vertex AI Agent Engine, hosts agents built with ADK, LangChain, LangGraph, AG2, LlamaIndex or any container that meets its contract. It bundles Sessions, Memory Bank and a sandbox for code execution and computer use, and Google says agents can run for up to 7 days. Google's closest CMA analog is separate: [Managed Agents](https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/managed-agents) provisions a Linux sandbox and runs the Antigravity harness on Gemini models, in preview on the Gemini API and Pre-GA on Agent Platform. **How it differs from CMA:** ADK is Apache-2.0 and supports Gemini natively, with Claude, OpenAI and others through connectors such as [LiteLLM](https://adk.dev/agents/models/). The catch: you write the agent and Agent Runtime hosts it, on Google Cloud only. **Choose it over CMA when:** you're on Google Cloud or want Gemini as your main model. **Pricing basis:** $0.085 per vCPU-hour, $0.009 per GiB-hour and $0.30 per GiB-month of storage. Since June 17, 2026, these unified SKUs cover Runtime, the code sandbox, Sessions and Memory Bank ([pricing](https://cloud.google.com/products/gemini-enterprise-agent-platform/pricing)). Sessions and Memory Bank also have read/write operation charges, and memory generation and embedding can add model charges. Managed Agents bills model usage at standard rates during preview. #### [Cloudflare Agents](https://developers.cloudflare.com/agents/) + Think: best for TypeScript on Cloudflare **What it is:** The Agents SDK (MIT) gives each agent durable identity, local SQL storage, scheduled tasks, real-time connections and recoverable execution, and idle agents hibernate with zero compute. [Think](https://developers.cloudflare.com/agents/api-reference/think/) (`@cloudflare/think`) adds an opinionated harness: the agentic loop, persistent sessions, compaction, sub-agents and sandboxed code execution. **How it differs from CMA:** Any model through the AI SDK (Workers AI by default; OpenAI, Anthropic or Gemini can be swapped in). Think is marked experimental, and the platform is built to run on Cloudflare, not your own servers. **Choose it over CMA when:** you're a TypeScript team on Cloudflare that wants many mostly idle per-user agents. **Pricing basis:** Workers Paid has a $5/month minimum. Past included amounts, [Durable Objects](https://developers.cloudflare.com/durable-objects/platform/pricing/) cost $0.15 per million requests, $12.50 per million GB-seconds and $0.20 per GB-month of storage; hibernating objects incur no duration charges. ### If you already build on LangGraph #### [LangSmith Deployment](https://docs.langchain.com/langsmith/deployment) + Deep Agents: best for LangGraph teams **What it is:** LangSmith Deployment runs agents from any framework on Agent Server, with durable checkpoints, crons, a task queue and human-in-the-loop. [Deep Agents](https://github.com/langchain-ai/deepagents) is LangChain's MIT-licensed harness, and [Managed Deep Agents](https://www.langchain.com/blog/managed-deep-agents-is-now-in-public-beta) (public beta since August 7, 2026) deploys one with a single command, giving each thread its own sandbox by default. **How it differs from CMA:** Model-agnostic. Managed Deep Agents is currently US-region LangSmith Cloud only, and CLI-first. You can self-host Agent Servers, but the full platform needs the Enterprise plan and a standalone server needs a LangSmith license. **Choose it over CMA when:** you already use LangGraph or LangSmith for tracing and evals, or want explicit graph control over parts of the agent. **Pricing basis:** [Plus](https://www.langchain.com/pricing) is $39 per seat per month with one free small deployment. Runtime is 0.0675 LSU per vCPU-hour plus 0.009 LSU per GiB-hour (1 LSU = $1) for as long as a deployment is up, plus database compute. We found no separate Managed Deep Agents price. ### If you want a different vendor's managed harness #### [OpenAI Agents API](https://developers.openai.com/api/docs/guides/agents-api/overview): best if you want OpenAI's Codex harness **What it is:** The Codex harness as an OpenAI-managed API, in public beta since September 10, 2026. OpenAI handles sessions, orchestration, compaction and recovery. Sessions run with no sandbox, in an [OpenAI-hosted Linux sandbox](https://developers.openai.com/api/docs/guides/agents-api/environments/openai-hosted) (1 vCPU/1 GB, 2 vCPU/4 GB by default, or 4 vCPU/16 GB), or against a `codex exec-server` executor on your machines or a partner such as Modal, E2B, Daytona or Vercel. **How it differs from CMA:** Same shape, different vendor: OpenAI's models instead of Claude. It's also beta, with US-only data residency and no ZDR, even with a self-hosted sandbox. A hosted sandbox can be deleted after an hour without activity or keep-alives; connected sandboxes receive keep-alives even between turns, and files in `/workspace/outputs` survive as artifacts. The Codex harness is Apache-2.0. **Choose it over CMA when:** you prefer OpenAI's models, want computer use (added September 29), or want many sandbox partners. See [camelRun vs OpenAI Agents API](https://camelai.com/blog/camelrun-vs-openai-agents-api). **Pricing basis:** No additional fee for the API: tokens and tools, plus hosted sandboxes at [container rates](https://developers.openai.com/api/docs/pricing) of $0.03 (1 GB), $0.12 (4 GB) or $0.48 (16 GB) per 20-minute session. Eligible container sessions bill by the minute with a 5-minute minimum. ### If you want to stay on Claude but own the infrastructure #### Self-host the Claude Agent SDK: best for staying on Claude with your own infrastructure **What it is:** Claude Code's harness as a library. Each session is a `claude` subprocess that owns a shell, a working directory and its transcripts, inside containers you operate. **How it differs from CMA:** You take over what CMA manages: containers (Anthropic's [hosting guide](https://code.claude.com/docs/en/agent-sdk/hosting) suggests 1 GiB RAM, 5 GiB disk and 1 CPU per agent to start), session persistence via a `SessionStore`, tenant isolation, egress proxying and scaling. It's still Claude-only, but it can reach Claude through Anthropic's API, Amazon Bedrock or Google Cloud. Claude Code and the TypeScript SDK are under Anthropic's Commercial Terms. **Choose it over CMA when:** you're committed to Claude but need sessions and files on your infrastructure, billing through a cloud provider, or full control of the container. See our guide to [hosting the Claude Agent SDK](https://camelai.com/blog/how-to-host-claude-agent-sdk). **Pricing basis:** Claude tokens plus your compute; Anthropic puts a minimally provisioned container at roughly $0.05 per hour. ## Also worth watching - **[DigitalOcean Managed Agents](https://docs.digitalocean.com/products/managed-agents/)** (public preview since September 21, 2026) runs Claude Code, Codex, OpenCode, LangGraph agents or your own OCI image in microVM sandboxes you can pause, resume and fork. Unranked: we couldn't find per-unit runtime rates on its official pages. - **[OpenMA](https://github.com/openma-ai/open-managed-agents)** is an Apache-2.0 community project that implements the CMA API (`/v1/agents`, `/v1/sessions`) with your choice of models, self-hosted on Node, Docker or Cloudflare, or hosted. It could make migration the smallest change, but it's young and we couldn't verify hosted pricing. - **Bring-your-own-container runtimes** such as Microsoft Foundry hosted agents are covered in our [AI agent runtimes and hosting platforms comparison](https://camelai.com/blog/ai-agent-runtimes-hosting-platforms). ## When staying on Claude Managed Agents is the right call Stay on CMA when: - **Your agent needs a real Linux machine.** The [cloud sandbox](https://platform.claude.com/docs/en/managed-agents/cloud-sandboxes-reference) is Ubuntu 24.04 with up to 8 GB RAM and 10 GB disk, with Python, Node, Go, Rust, Java, Postgres, Redis, Playwright with Chromium, LibreOffice and ffmpeg preinstalled. Coding, data and document agents get all of that with no setup, which camelRun can't offer. - **You're happy on Claude** and want Anthropic to run everything, including scheduled deployments, credential vaults and memory stores. - **Your only problem is where tools run.** Try self-hosted sandboxes before migrating; files, processes and network traffic stay in your environment. - **The meter suits you.** At $0.08 per session-hour, idle time (waiting on you or a tool confirmation) isn't billed. ## FAQ **Is there an open source Claude Managed Agents alternative I can self-host?** Yes. For self-hosted managed agents, camelRun (AGPL-3.0 runtime, MIT SDKs) and Letta (Apache-2.0) run either as hosted services or entirely on your infrastructure, and OpenMA reimplements the CMA API under Apache-2.0. Deep Agents, Cloudflare's Agents SDK and OpenAI's Codex harness are open source too, but their managed services aren't. **Can I keep using Claude models if I switch?** On most of these, yes: camelRun, Letta, AgentCore (through Bedrock), LangSmith, Cloudflare and ADK can all call Claude and let you add other providers alongside it. The OpenAI Agents API is the exception. **How much work is migrating off CMA?** Your system prompt, tool schemas and remote MCP servers carry over to most of these platforms. You rebuild the integration layer (each API has its own events and session model) and anything that depends on CMA's Ubuntu sandbox, skills or memory stores. If the agent relies on bash and file tools, pick a destination with a Linux sandbox. ## Try camelRun If model choice and portability are why you're looking, camelRun is a hosted runtime for durable agents that you can also run yourself, at $0.01 per agent-hour of active run time plus model usage. Start with the [quickstart](https://camelai.com/docs/camelrun/quickstart), read the [docs](https://camelai.com/docs/camelrun/overview), or see the [camelRun product page](https://camelai.com/run).