Five products host an AI agent for you in 2026, and they split into two kinds. Three run their own agent loop and you configure it: Claude Managed Agents, OpenAI’s Agents API, and Cadenya. Two run the loop you write: LangSmith Deployment and Amazon Bedrock AgentCore.

After that, a few facts decide most picks: which models you can use, how long a durable session waits for a human-in-the-loop approval, whether a dropped stream can resume, what you pay for, and what you can self-host.

Every figure below comes from the vendors’ own docs and pricing pages, checked on September 28, 2026.

The short version

• Claude Managed Agents if you want Claude with a sandbox per session and approvals that wait as long as they need to.
• LangSmith Deployment if you write the agent yourself (LangGraph or another framework) and want it hosted in the US or the EU.
• Amazon Bedrock AgentCore if you write the agent, need any model on AWS, and need HIPAA eligibility or FedRAMP.
• OpenAI’s Agents API if you want OpenAI’s managed harness and OpenAI models, and can live with a beta.
• Cadenya if your agent’s tools are your own API, you want any model with nothing to run (what it offers).

Pricing, models, and who writes the loop

	Claude Managed Agents	LangSmith Deployment	Amazon Bedrock AgentCore	OpenAI Agents API	Cadenya
Who writes the loop	Anthropic’s harness	You	You	OpenAI’s Codex harness	Cadenya, configured by you
Models	Claude 4.5 and later, fixed per session	Whatever your code calls	Any: Bedrock, OpenAI, Gemini, Claude, and more	OpenAI models, can change between turns	Any provider you connect, set per variation
Price	$0.08 per session-hour while running, plus tokens	Plus: $39 a seat a month, plus $0.0675 per vCPU-hour of runtime	$0.0895 to $0.1276 per vCPU-hour, plus memory, billed per second	Model tokens, tools, and $0.03 per 20 minutes for a 1 GB sandbox	$0 for 1,000 loops a month, $49 for 50,000
Status	Beta	Some features in beta	The harness is GA, other parts vary	Beta	Live, SDKs at 1.7.0

Session limits, idle timeouts, and human-in-the-loop approvals

	Claude Managed Agents	LangSmith Deployment	Amazon Bedrock AgentCore	OpenAI Agents API	Cadenya
Longest session	Not stated	Not stated	8 hours on microVMs, 14 days on Instances	Not stated	Not stated
When idle	Idle time isn’t billed	Not stated	Ends after 15 minutes by default, up to 8 hours	A hosted sandbox goes after an hour without activity	A timeout you set per variation, from 1 minute to 24 hours
Human approval	always_ask, which “waits indefinitely”	LangGraph interrupt(), which “waits indefinitely”	A harness hook to Lambda, 1 to 900 seconds, denied on timeout	None in the API (the Agents SDK has one)	Tool approvals, answered from the API, a webhook, Slack, or the React widget
Streaming after a dropped connection	Not stated	Resumes from the last event ID, and join_stream attaches to a running thread	Not stated	Streams “do not replay missed events”	Resumes from the last event ID, and the TypeScript SDK reconnects on its own
Your API as tools	MCP (up to 20 servers) and custom tools	Your code	Gateway turns OpenAPI, Smithy, and Lambda into MCP tools	MCP and function tools	OpenAPI 3 (checked hourly), MCP, HTTP, and Bare tools
Code the model writes	A container per session: bash, files, web	LangSmith Sandboxes, sold separately	Code Interpreter: Python, JavaScript, TypeScript	A hosted sandbox or your own executor	Pairs with a sandbox such as E2B through a tool
Where it runs, and self-hosting	Anthropic. Tools can run in your own sandbox	LangChain’s cloud in the US or EU. Enterprise can self-host	AWS, with VPC and PrivateLink	OpenAI. The executor can run on your side	Cadenya’s cloud, with nothing for you to run
Compliance lines	Not eligible for ZDR or HIPAA	None found in its docs	HIPAA eligible, FedRAMP, SOC 2, ISO	US data residency only, no ZDR	Execution logs deleted after 14 days

Claude Managed Agents

Anthropic’s “pre-built, configurable agent harness that runs in managed infrastructure.” Each session gets a sandbox where Claude can run bash, read and write files, and search the web, and you pay $0.08 per session-hour only while the session is running, plus tokens at the usual rates (Claude Sonnet 5 is $2 and $10 per million input and output tokens). Time spent idle, waiting for you or for a tool confirmation, is free.

Human-in-the-loop approvals are a permission policy. Set a tool to always_ask and “the session waits indefinitely for a response”, which you send as a user.tool_confirmation event. It connects up to 20 MCP servers, and there are SDKs in seven languages.

The limits are on the other side of the page. It’s Claude only, and the model “can’t change mid-session.” It’s in beta. It “is not currently eligible for Zero Data Retention or HIPAA Business Associate Agreement (BAA) coverage”, and "us" is the only workspace geo. There’s no OpenAPI import, so your API reaches it as MCP or as custom tools you execute. Pick it when the agent should do things in a sandbox and Claude is the model you want.

LangSmith Deployment

LangChain’s “workflow orchestration runtime purpose-built for agent workloads,” formerly LangGraph Platform. You write the agent, in LangGraph or, through a wrapper, the Claude Agent SDK, Strands, CrewAI, AutoGen, or Google ADK, and its Agent Server hosts it. Deployments live in the US or the EU.

Pricing mixes seats and metering. Plus is $39 a seat a month, includes one free Serverless (Small) deployment, and bills runtime at $0.0675 per vCPU-hour and $0.009 per GiB-hour, with databases for Dedicated deployments on top. Self-hosting is “an add-on to the Enterprise plan” with a license key, and it brings ClickHouse, Postgres, Redis, and Kubernetes with it.

Approvals are LangGraph interrupts, and the graph “waits indefinitely until you resume execution.” Streams are resumable too: “if a connection drops, reconnect with the last event ID to pick up where you left off.” Two catches from the same docs: a resumed node runs again “from the beginning”, and old checkpoints pile up until you prune them. Pick it when you want to own the agent’s code and have someone else run it. LangSmith Deployment pricing and alternatives goes deeper.

Amazon Bedrock AgentCore

AWS’s “agentic platform for building, deploying, and operating highly effective agents securely at scale using any framework and foundation model.” It’s a set of parts: Runtime (your agent in its own microVM per session), Memory, Gateway, Identity, Code Interpreter, Browser, and Observability. It runs CrewAI, LangGraph, LlamaIndex, Google ADK, the OpenAI Agents SDK, and Strands, with any model.

Runtime bills per second of real use: $0.0895 per vCPU-hour and $0.00945 per GB-hour on v1 microVMs, with “no upfront commitments or minimum fees.” AWS’s own worked example, a support agent with 1 million sessions a month, comes to $6,703. The compliance list is the longest here: HIPAA eligible, FedRAMP, SOC 2, and seven ISO standards.

The limits are about time. A session runs “up to 8 hours on microVMs”, and one idle for 15 minutes ends by default. The built-in approval point is a hook that calls a Lambda function, which times out between 1 and 900 seconds and denies by default. Pick it when you’re on AWS, you write the agent, and the waits are short. AgentCore alternatives covers the options.

OpenAI’s Agents API, and the rest of AgentKit

OpenAI’s agent pieces ship separately. The Agents API “gives your application access to the Codex harness through an OpenAI-managed API”, with sessions, compaction, and recovery, in beta. The Agents SDK runs the loop in your own app instead. ChatKit is an embeddable chat UI (the pricing page files its storage under “Agent Kit”). And Agent Builder, the visual canvas, “is scheduled to shut down on November 30, 2026.”

The Agents API bills model tokens, tools, and sandboxes: $0.03 per 20 minutes for a 1 GB container, by the minute after a 5-minute minimum. You can change the model between turns of a session. But it “supports data residency only in the United States and does not support Zero Data Retention”, its streams “do not replay missed events”, and it has no approval step of its own (the Agents SDK has one). Pick it when you want OpenAI’s harness and OpenAI models, managed.

How to choose

Answer five questions in order:

1. Does the agent need more than one model vendor? That rules out Claude Managed Agents and the Agents API.
2. Do you want to write and host the agent loop yourself? LangSmith Deployment and AgentCore run the code you write. Cadenya runs the loop for you, on any model.
3. Are the agent’s tools your own API? Cadenya turns an OpenAPI document into tools and re-checks it each hour. AgentCore needs Gateway, and the others take MCP servers or tools your code runs.
4. Does the agent run code it writes? Managed Agents, AgentCore, and the Agents API include a sandbox. LangSmith sells one, and Cadenya pairs with one.
5. Must the data stay in your cloud or in the EU? AgentCore runs in AWS regions in Europe and connects to your VPC through PrivateLink, and LangSmith Deployment offers an EU region and self-hosting on Enterprise.

What does Cadenya offer that the other four don’t?

Claude Managed Agents and OpenAI’s Agents API run the loop, on their own models. LangSmith Deployment and AgentCore run any model, and you write the loop. Cadenya runs the loop for you, on any model, with your own API as the tools. Here’s what that covers:

1. Any model, with no vendor tie. Managed Agents runs Claude, and the Agents API runs OpenAI models. On Cadenya, the model is a setting on a variation: any model on OpenRouter or your own endpoint that speaks the OpenAI chat format, on your own keys. Weighted variations route more traffic to whichever model or prompt users rate higher.
2. The loop, already written, with nothing else to run. LangSmith Deployment and AgentCore host the agent you write. On Cadenya you set the prompt, model, tools, and approvals on a variation, and Cadenya calls the model, runs the tools, streams each reply, and compacts the context window. There’s no agent code to deploy and no self-hosted runtime to size.
3. Built for product agents, not coding agents. Managed Agents gives Claude a shell and a container, and the Agents API runs the Codex harness. A Cadenya agent works through your product’s API, sits in your app as a chat widget, and acts as the signed-in user.
4. Your OpenAPI document as the tools. A tool set turns every operation in an OpenAPI 3 document into a tool, re-checks the document each hour, filters the list, and loads tools on demand, so a big API doesn’t fill the context window. Managed Agents and the Agents API take MCP servers or tools your own code runs, and AgentCore needs Gateway, at $0.005 per 1,000 calls.
5. Human-in-the-loop approvals, screen included. Mark a tool as needing approval and the objective pauses on toolApprovalRequested until someone approves or denies it: your backend, a webhook handler that posts to Slack, or a person in the React chat widget. A denial can carry a memo that steers the agent. The Agents API has no approval step, and AgentCore’s hook waits 900 seconds at most.
6. Acting on behalf of the signed-in user. Your backend mints a widget session per user, and it can carry that user’s short-lived token as a secret that overrides the shared API credential, so your API sees the user’s own token on each tool call. AgentCore leaves that to you: “your client backend should maintain the relationship between users and their session IDs.”
7. Resumable streaming. The event stream honors Last-Event-ID, and the TypeScript SDK reconnects on its own. The Agents API’s streams “do not replay missed events.”
8. Durable state that outlives your deploys. Every objective keeps a durable event log on Cadenya that you can list, stream, or receive as signed webhooks. An objective also keeps its variation’s snapshot, so editing the agent never changes a conversation that’s already running.
9. Dated releases and no beta header. Managed Agents and the Agents API are in beta. Cadenya’s API needs no beta header, its TypeScript and Python SDKs reached 1.0 on August 15, 2026, and all four SDKs (TypeScript on Node 18, Python 3.9, Ruby 3.1, and Go 1.22) shipped 1.7.0 on September 28, under Apache-2.0.
10. A price per model call, not per hour. Free for 1,000 loops a month, $49 for 50,000, then $0.0015 a loop, where a loop is one LLM request. Waiting for a person costs nothing, and there are no seats, session-hours, or vCPU-hours to estimate.

The tool sets guide shows how your API becomes an agent’s tools, and the free plan needs no card.