---
title: 'camelRun vs Claude Managed Agents: Which Should You Use?'
published date: '2026-10-06'
author: 'Illiana Reed'
title-image: 'https://camelai.com/blog/assets/images/covers/camelrun-vs-claude-managed-agents.png'
---

**TL;DR:** camelRun vs Claude Managed Agents comes down to where your agent's work happens. Choose Claude Managed Agents if you build on Claude only and your agent needs a real Linux machine: bash, a filesystem, package installs, builds and browsers. Choose camelRun if you're putting long-lived agents inside your product and want any model (Claude included), tools that stay in your own code, built-in Slack, Discord, Telegram and GitHub channels, or the option to self-host. Both meter active time rather than wall-clock time, on top of tokens ($0.08 per running session-hour vs $0.01 per active agent-hour), and tokens are usually the bigger number.

---

## camelRun vs Claude Managed Agents at a glance

| | Claude Managed Agents | camelRun |
|---|---|---|
| **What it is** | Anthropic's hosted agent harness plus a cloud sandbox, driven by API | A hosted runtime for long-lived agents inside your product, also self-hostable |
| **Models** | Claude 4.5 and later | Any: Anthropic, OpenAI, OpenRouter, Amazon Bedrock, or an OpenAI- or Anthropic-compatible server |
| **Code the model runs** | Bash, files and many languages in an Ubuntu container | JavaScript only, in a sandbox with no shell, packages or network |
| **Your tools** | Custom tools your app answers over the event stream, plus MCP servers | Functions in your TypeScript or Python code, HTTP-served tools, MCP or OpenAPI |
| **State** | Per session; memory stores carry knowledge across sessions | Per agent, keyed by your own id, kept until you delete it |
| **Chat channels** | Anthropic's documented Slack integration uses a bot your app runs | Slack, Discord, Telegram, GitHub, generic webhooks |
| **Source and hosting** | Closed; sandbox can be self-hosted, orchestration stays with Anthropic | Runtime AGPL-3.0, SDKs MIT; self-host with Docker and Postgres |
| **Platform meter** | $0.08 per session-hour while running, plus tokens | $0.01 per agent-hour of active run time, plus model usage and storage |

## What is Claude Managed Agents?

[Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview) is Anthropic's pre-built agent harness running on Anthropic's infrastructure. If you've seen it called Anthropic Managed Agents, it's the same product. It [launched in public beta on April 8, 2026](https://claude.com/blog/claude-managed-agents) and is still in beta: every endpoint needs the `managed-agents-2026-04-01` header, and access is on by default for API accounts.

You work with four objects:

- **Agent:** the model, system prompt, tools, MCP servers and skills. Agents are versioned.
- **Environment:** where sessions run, either an Anthropic-managed cloud sandbox or a [self-hosted sandbox](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes) on your infrastructure.
- **Session:** a running instance of an agent in an environment, with its own history and filesystem.
- **Events:** what your app and the agent exchange (user messages, tool results, status changes), streamed over SSE.

Anthropic runs the loop, with prompt caching and compaction, and executes the built-in tools: bash, read, write, edit, glob, grep, web search and web fetch. Bash and the file tools run in a per-session [Ubuntu 24.04 container](https://platform.claude.com/docs/en/managed-agents/cloud-sandboxes-reference) with up to 8 GB of RAM and 10 GB of disk. It comes with Python, Node.js, Go, Rust, Java, Ruby, PHP and C/C++, plus Postgres, Redis, Playwright with Chromium, LibreOffice and ffmpeg. You can steer or interrupt a running session.

Around that core sit custom tools, MCP servers with credentials held in [vaults](https://platform.claude.com/docs/en/managed-agents/vaults), skills, versioned [memory stores](https://platform.claude.com/docs/en/managed-agents/memory), multiagent orchestration, outcomes graded against a rubric, cron-style scheduled deployments, webhooks, per-session spend budgets and permission policies. MCP tunnels and "dreaming" are in a narrower research preview.

On data, Anthropic says Managed Agents is not currently eligible for Zero Data Retention or HIPAA BAA coverage, because sessions store history, sandbox state and outputs on Anthropic's side. You can delete sessions and uploaded files through the API.

## What is camelRun?

camelRun is camelAI's hosted runtime for AI agents. You define each agent's model, instructions, tools and channels. camelRun runs the agent loop and keeps each agent's history and files, compacting long histories. It runs model-written JavaScript in a sandbox and wakes agents when there's work: a message, a schedule, a channel event, a webhook or a human approval. Agents are keyed by your own ids, so you can give each customer, ticket, thread or PR its own agent. Most of them are asleep at any moment.

We built it because we kept rebuilding it. It's the fifth time our team has built agent infrastructure in three years, and moving camelCode's agents onto camelRun let us delete about 72,000 lines of code. [Our intro post](https://camelai.com/blog/the-web-wasnt-built-for-agents) has the full story.

Here is the [quickstart](https://camelai.com/docs/camelrun/quickstart) agent, copied from the docs:

```ts
import { Agents, schema, tool } from "@camelai/run";

const agents = new Agents(); // reads CAMELAI_API_KEY

// A tool is an ordinary function: it runs here, in your process.
const weather = tool({
  description: "Today's weather in a city",
  input: schema.Object({ city: schema.String() }),
  execute: ({ city }) => ({ city, forecast: "sunny", highC: 24 }),
});

// The same key is the same agent, with its history, every time you run this.
const agent = await agents.upsert("quickstart", {
  instructions: "You are a concise assistant.",
  tools: { weather },
});

const run = await agent.run("Should I bring an umbrella in Lisbon today?");
console.log(run.text);

await agents.close();
```

The runtime calls `weather` in your process over the SDK's connection. Run the file again and `upsert("quickstart", …)` returns the same agent, history included.

## Claude Managed Agents comparison: head-to-head

### Model choice

Claude Managed Agents supports [Claude 4.5 and later models](https://platform.claude.com/docs/en/managed-agents/agent-setup). You can set effort, fast mode and inference geography per agent, and override the model for a single session when you create it. The model can't change mid-session.

camelRun takes any model as a `provider/model-id`: Anthropic, OpenAI, OpenRouter, Amazon Bedrock, or your own server that speaks OpenAI's or Anthropic's API, such as vLLM or Ollama. You can [switch an existing agent's model](https://camelai.com/docs/camelrun/models-and-keys) between runs and its history carries over. The hosted default is Claude Sonnet 5.5, so choosing camelRun doesn't mean giving up Claude. You can use your own provider keys, or let each customer bring theirs through key scopes.

### Where the agent's code runs

This is the biggest difference, and for some workloads it settles the question in Anthropic's favor.

Claude Managed Agents gives the model a Linux computer: it can clone a repo, install dependencies, run tests, convert documents or drive a browser. A self-hosted sandbox puts that computer on your own machines.

camelRun gives the model `js_exec`: JavaScript in a sandbox that can call the agent's tools (in parallel with `Promise.all`) and read its files. There's no shell, no Python, no package installs and no network, and an execution runs for at most 120 seconds. Your tools can use Python, packages and network access in your own process, but they have their own deadlines, and calls made from `js_exec` also end when that execution ends. camelRun's Python SDK defines tools in Python; it doesn't give the model Python to run.

So if the job is "check out the branch, install, build and run the tests", camelRun is the wrong fit: use Claude Managed Agents, or a coding harness in your own container (our guide on [how to build an AI agent](https://camelai.com/blog/how-to-build-an-ai-agent) compares those routes). If the job is "look up the order, issue the refund and reply in the thread", the work happens in your APIs, and a Linux box adds little.

### State and lifetime

In Claude Managed Agents the unit of state is the session. First-party sessions have no runtime limit when running unattended (on Claude Platform on AWS they need a user event every 6 hours). History persists until you delete the session, but [sandbox state lasts 30 days from creation](https://platform.claude.com/docs/en/managed-agents/events-and-streaming), even if the session stays active. After that window, resuming starts a fresh sandbox; save important files as outputs before it expires. A new session starts with fresh context, and memory stores carry knowledge across sessions. Your app tracks which session belongs to which user or thread, as Anthropic's [Slack bot cookbook](https://platform.claude.com/cookbook/managed-agents-slack-data-bot) does with a thread-to-session dictionary.

In camelRun the unit of state is the keyed agent. `upsert(key)` returns the same agent from any process until you delete it, with its history, files and pending work stored in the runtime. Runs have no overall timeout, and the runtime can resume an interrupted turn on another node. Recovery has limits: interrupted code executions and turns already resumed twice can fail with an `uncertain` outcome. [The error reference](https://camelai.com/docs/camelrun/errors) explains what to check before retrying.

Durable history doesn't mean exactly-once side effects. If a tool call's answer is lost, camelRun never sends the call again. Instead the model is told the outcome is unknown, so it can check before acting, and every call carries an idempotency key to pass to anything with side effects.

### Tools and credentials

Claude Managed Agents has the built-in toolset, MCP servers that Anthropic calls with credentials from vaults (refreshing OAuth tokens for you), and [custom tools](https://platform.claude.com/docs/en/managed-agents/tools) that your app runs. For a custom tool, the session emits `agent.custom_tool_use`, pauses, and resumes when you send back `user.custom_tool_result`. Secrets stored as environment variables are swapped in at the network boundary, so the agent never sees them.

camelRun [tools](https://camelai.com/docs/camelrun/tools) can be functions in your process, or an HTTPS endpoint of yours: the runtime signs each call with who it's for, which suits serverless and multi-tenant backends. They can also be OpenAPI and MCP sources that the runtime calls with credentials it stores sealed. Built-ins cover web search, web fetch, schedules and questions to the user.

Both platforms provide ways to keep credentials outside model-visible tool definitions; your tools must still avoid exposing secrets in their results. The integration differs: in camelRun a tool is a function you pass to `upsert`, while in Claude Managed Agents you handle tool-call events. Anthropic has SDKs in seven languages (Python, TypeScript, Go, Java, C#, PHP and Ruby). camelRun has TypeScript and Python; other languages use the REST API or serve tools over HTTP, MCP or OpenAPI.

### Channels, triggers and human approval

Claude Managed Agents reaches your app through SSE events, webhooks and scheduled deployments. In [Anthropic's documented Slack integration](https://platform.claude.com/cookbook/managed-agents-slack-data-bot), you run a Bolt bot that relays messages to sessions and sends results back to Slack. Approval works through [permission policies](https://platform.claude.com/docs/en/managed-agents/permission-policies) on built-in and MCP tools: `always_allow`, `always_ask`, or `auto`, which lets the server decide per call. A session waiting for confirmation goes idle and waits indefinitely. Custom tools aren't covered by these policies, since your app already decides whether to run them.

camelRun has built-in [channels](https://camelai.com/docs/camelrun/channels): Slack, Discord, Telegram, GitHub (through your GitHub App) and a generic webhook channel for services like Sentry, Linear or Stripe, with one agent per conversation, thread or PR. For [human input](https://camelai.com/docs/camelrun/human-input), any tool can require approval, the model can ask multiple-choice questions, and tools can ask for forms. The run suspends and the agent sleeps, with no agent-time charges, until someone answers from any process or in the channel thread. Inputs wait 7 days by default, up to 30. From the docs:

```ts
let run = await agent.run("Delete the staging database", { user: "alice" });
while (run.status === "input_required") {
  const input = run.inputs[0];
  console.log(input.kind, input.message);          // "approval", "Allow db__drop to run?"
  run = await input.answer(true, { from: "alice" }); // resolves with the resumed run
}
console.log(run.text);
```

### Open source and self-hosting

Claude Managed Agents is closed source and hosted by Anthropic. A self-hosted sandbox keeps tool execution, files and network egress inside your infrastructure. Anthropic ships worker code, and sandbox providers such as Cloudflare, Daytona, E2B, Modal and Vercel publish guides. But orchestration stays with Anthropic: tool inputs and outputs still pass through Anthropic's control plane, and Anthropic stores skills and memory stores.

camelRun's runtime is open source under AGPL-3.0, with MIT-licensed SDKs, and a commercial license is available. [Self-hosting](https://camelai.com/docs/camelrun/self-hosting) takes one Docker container and Postgres, with local or S3-compatible storage, and doesn't need AWS. The loop, history and files all run on your servers. Model calls go to whichever provider you configure.

## Claude Managed Agents pricing vs camelRun pricing

Both meter active time plus model tokens, in different units, and camelRun adds storage:

| Billing unit | Claude Managed Agents | camelRun (hosted) |
|---|---|---|
| **Platform time** | $0.08 per session-hour, metered by the millisecond while the session is `running` | $0.01 per agent-hour of active run time (model calls and tool execution) |
| **Not metered** | Idle (waiting for your message, a tool confirmation or a custom tool result), rescheduling, terminated | Idle and sleeping agents, and runs waiting on a person |
| **Model tokens** | Claude list rates; caching discounts apply; no batch discount | Your provider key: $0 from camelRun, billed by your provider. Our keys: the provider's price, no runtime markup |
| **Storage** | No separate line on the pricing page | $0.10 per GB-month |
| **Web search** | $10 per 1,000 searches | $0.001 to $0.007 per search |
| **Payment** | Billed on monthly usage | Prepaid credit; purchases carry a 5.5% processing fee |

*Pricing verified October 2026. Self-hosted camelRun has no camelRun meter: you pay for your own servers and model usage.*

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

Two details matter more than the headline rates:

- **What counts as active.** Claude Managed Agents stops the meter while a session waits on your custom tool. camelRun's agent-hour includes the time your tools take to answer.
- **What the meter buys.** Anthropic's $0.08 includes a Linux container with up to 8 GB of RAM. camelRun's $0.01 covers the loop and the JavaScript sandbox. An hour-long build-and-test job costs $0.08 of runtime on Claude Managed Agents, and camelRun can't run it at all.

### A worked example

Here is an illustrative workload, not a benchmark: a support assistant inside a SaaS app.

- 1,000 conversations a month, 3 turns each: 3,000 turns.
- 20 seconds of active work per turn, 4 seconds of which is your app's tools answering.
- The same model on both, Claude Sonnet 5.5 ($2 input / $10 output per million tokens). camelRun uses your Anthropic key.
- 20,000 input and 800 output tokens per turn, before caching, assumed equal on both.
- 0.5 GB of stored history on camelRun.

Claude Managed Agents doesn't meter the 4 seconds a session waits on your tools, so it bills 16 seconds a turn; camelRun bills all 20.

| Line item | Claude Managed Agents | camelRun |
|---|---|---|
| **Platform time** | 3,000 × 16 s = 13.3 session-hours × $0.08 = **$1.07** | 3,000 × 20 s = 16.7 agent-hours × $0.01 = **$0.17** |
| **Storage** | none listed | 0.5 GB-month × $0.10 = **$0.05** |
| **Tokens (billed by Anthropic)** | 3,000 × ($0.040 + $0.008) = **$144** | 3,000 × ($0.040 + $0.008) = **$144** |

At this workload the platform meter is under 1% of either bill. In practice the two harnesses won't use exactly the same tokens: system prompts, tool definitions, compaction and caching all differ, and that gap can outweigh the meter. Measure your own workload before choosing on price.

## When to choose Claude Managed Agents

- **You're a Claude-only shop** and want the model, harness, sandbox and memory from Anthropic, on one bill.
- **Your agent needs bash or Linux:** coding and file-heavy work, package installs, builds and tests, document and media tools or browser automation, often long-running and asynchronous.
- **You want Anthropic-managed everything,** including extras camelRun doesn't have: versioned memory stores, rubric-graded outcomes, multiagent orchestration, skills and the `auto` permission policy.
- **You need an SDK beyond TypeScript and Python.**
- **You buy through AWS.** Claude Managed Agents is also available on Claude Platform on AWS, billed through AWS Marketplace, with some feature and session differences.

## When to choose camelRun

- **You're putting agents inside your product:** one per customer, ticket, thread or PR, keyed by your own ids, mostly asleep.
- **You want model choice,** or the ability to switch an agent's model without losing its history.
- **Your tools are your app's APIs,** and you want them to stay in your code with your auth and credentials.
- **You want Slack, Discord, Telegram or GitHub** without writing the bot plumbing yourself.
- **People need to approve or answer,** sometimes days later, on any tool.
- **You need to self-host** or want an open-source runtime you can read and change.

If your agent needs a shell, camelRun isn't the right runtime. Our roundup of [Claude Managed Agents alternatives](https://camelai.com/blog/claude-managed-agents-alternatives) covers options with Linux sandboxes that aren't tied to Claude.

## FAQ

**Can camelRun host the Claude Agent SDK or Claude Code?**
No. camelRun runs its own agent loop; you bring instructions and tools, not a harness. To run the Agent SDK in your own containers, see [how to host the Claude Agent SDK in production](https://camelai.com/blog/how-to-host-claude-agent-sdk).

**Can I move an agent from Claude Managed Agents to camelRun?**
The parts that live in your app move over directly. The system prompt becomes `instructions`, each custom tool becomes a camelRun tool, and remote MCP servers become MCP sources. Anything that depends on bash, the preinstalled packages or the Linux filesystem doesn't port. Shared knowledge from memory stores can live in files on a volume shared by several agents.

**Can I use both?**
Yes. A camelRun tool is your own code, so it can start a Claude Managed Agents session for a job that needs a Linux sandbox while camelRun keeps the per-customer conversation, channels and approvals. Those jobs pay both platform meters plus tokens.

## Try camelRun

camelRun is at [camelai.com/run](https://camelai.com/run), and the [quickstart](https://camelai.com/docs/camelrun/quickstart) gets a keyed agent with a tool running in a few minutes. It costs $0.01 per agent-hour of active run time, plus model usage, and the runtime is on [GitHub](https://github.com/qaml-ai/run) if you'd rather run it yourself.