Self-Hosted Claude Managed Agents Explained: Run Claude Agents Inside Your Own Walls

Self-hosted Claude Managed Agents is Anthropic’s answer to the question every security-conscious company has been asking about AI agents: can we get the productivity of autonomous coding agents without handing our code, our credentials and our session history to someone else’s cloud? On 12 November 2026, Anthropic said yes — with a condition. In a private beta announced that day, companies can now run the entire Managed Agents service inside their own cloud account or on-premises data centre, keeping the agent harness, the sandboxes, the credentials and the session history behind their own firewall.

The Claude model itself still runs outside, but everything around it moves home. In this guide, we explain what self-hosted Claude Managed Agents is, what exactly you run and what you do not, how the security model works, what features you give up, what it costs, and who should actually ask for access.

In this article:

What Are Self-Hosted Claude Managed Agents?

Self-hosted Claude Managed Agents is a deployment option, now in private beta, that lets a company run Anthropic’s whole Managed Agents service on its own infrastructure instead of on Anthropic’s. Managed Agents is Anthropic’s suite of composable APIs for building and deploying autonomous agents: it provides the agent harness, the sandboxes where agents run code, the credential handling, and the session history that turns a one-off prompt into a long-running worker. Until now, that service only ran on Anthropic’s own platform. With self-hosted Claude Managed Agents, the customer operates the server, the database and the workers, and the only part that still leaves the building is the call to the Claude model itself.

That distinction matters more than it first sounds. An AI agent is not a chatbot. A chatbot answers a question and forgets it. An agent works unattended for hours: it reads your code, runs your tests, opens your internal tools, triages your alerts and works through your bug backlog while nobody watches. To do that, it needs real access — to repositories, to package registries, to credentials, to production-adjacent systems. Every one of those access rights is a risk if it sits outside your control. Self-hosted Claude Managed Agents is Anthropic’s way of saying that the control plane for that access can live where your security team can see it, audit it and switch it off.

The announcement, published on 12 November 2026 under the title “Operate Claude Managed Agents inside your security perimeter”, puts it plainly: “With self-hosted Managed Agents, every part of the service runs in your own cloud or on-premise, including the harness, sandboxes, credentials, and session history.” Your developers still build agents with the same core APIs as the hosted service, so code written against the hosted platform does not need to be rewritten. What changes is where the service runs, who holds the data, and who is responsible when something goes wrong.

It is worth being precise about what this is not. Self-hosted Claude Managed Agents is not a copy of Claude running on your servers. It is not an offline Claude. The model — the intelligence that decides what the agent does next — still runs at Anthropic or at a cloud provider you choose, and every model call still carries the conversation so far, including tool inputs and results.

What moves home is the orchestration: the loop that drives the agent, the storage of everything it did, and the vault that holds the credentials it uses. If you wanted a fully offline model, you would be looking at open-weight models instead, and you would be giving up Claude’s capabilities to get there. Anthropic is selling control here, not independence from its model.

Engineer working in a data centre where self-hosted Claude Managed Agents runs on company infrastructure

What Launched on 12 November 2026

The 12 November announcement of self-hosted Claude Managed Agents did not arrive out of nowhere. It is the third step in a sequence Anthropic has been walking through 2026, and the sequence explains why the self-hosted option exists at all. The hosted Managed Agents service launched as a public beta on 8 April 2026, with Anthropic running all the infrastructure. On 19 May 2026, Anthropic added self-hosted sandboxes: customers could run the containers where agents execute code inside their own environment, while Anthropic still ran the service itself.

That solved one problem — agent code touching your systems from your own network — but left the service, the session history and the credentials on Anthropic’s side. The 12 November release moves the second half as well. The whole service, not just the sandbox, now runs on your infrastructure.

Why now? Anthropic’s own announcement gives the reason in plain language: agents have become more capable and are taking on more critical work — fixing broken builds, testing releases, triaging alerts, working through bug backlogs. They run unattended on your code and need access to your internal systems, and for agents with that level of access, some teams want the whole service in their own environment, not just the sandbox. Until now, the announcement says, that meant building the platform themselves. Self-hosted Claude Managed Agents is the alternative to that build-it-yourself project.

The timing also fits a wider pattern in the industry. A day earlier, on 11 November, Google’s Gemini API gained self-hosted sandboxes for its managed agents. The two announcements are not the same thing — Google moved the sandbox, Anthropic moved the whole service — but they point in the same direction: the agent platform vendors have realised that enterprise adoption stalls at the point where a security team asks where the agent’s history and credentials live. Whoever answers that question best wins the regulated industries.

Access is gated. There is no public signup page and no download link. Anthropic’s documentation says plainly: “To request access to self-hosted Claude Managed Agents, contact your Anthropic account team.” The release archive — the actual software — is handed out through that channel. No beta customers have been named publicly, no general-availability date has been published, and no public price exists.

That is normal for a private beta aimed at large organisations, but it means everything in this guide to self-hosted Claude Managed Agents comes from Anthropic’s announcement and documentation, not from hands-on testing. We have not run the stack, and neither has any independent reviewer we could find. Where a claim comes from Anthropic itself, we say so.

Self-Hosted Claude Managed Agents: What You Run, Piece by Piece

A self-hosted Claude Managed Agents deployment is made of six parts, according to Anthropic’s documentation. Three of them are the core you cannot skip, and the rest make the system usable and manageable. Understanding each piece is the fastest way to judge whether your team could actually operate this.

cma-server: the brain of self-hosted Claude Managed Agents

The core component is cma-server, a process that serves the Managed Agents API, runs the agent loop, and stores agents, sessions and session history. It is the same API as the hosted service, which is why the SDKs and the ant command-line tool work against your own server without modification. When your application starts an agent session, it talks to your cma-server, not to Anthropic’s platform. The server decides what the agent does next, calls the model when reasoning is needed, and records every step.

One design detail matters a lot: cma-server never runs an agent’s shell or file tools itself. It is the brain, not the hands. That separation is deliberate, and it is the first of the four security principles we cover below. The practical consequence is that even if an agent is tricked into running something malicious — a poisoned instruction in a file it reads, a compromised dependency — the code executes in a sandbox, not in the process that holds the session history and the vault.

PostgreSQL 16 or later: the memory

Persistent data lives in a PostgreSQL 16 or later database. Agents, sessions and session history all sit in your database, which is the whole point of the exercise for most buyers: the record of what your agents did, on your code, with your systems, stays in infrastructure you control, under your retention policies, visible to your auditors. The server can technically start without a database, but in that mode it keeps everything in memory, and a restart erases every agent and session. That mode exists for a quick trial, not for real use.

For production, Anthropic recommends Kubernetes, using the two Helm charts included in the release archive, with a PostgreSQL database the cluster can reach. The charts do not install the database for you, so you provision it separately. That is a meaningful operational commitment: you are now a database operator for your agent platform, with backups, access control and retention to manage. It is also the trade that buys you the data-residency story your compliance team wants.

Workers and sandboxes: the hands

The third core piece is the workers: programs that poll the server for work and run the agent’s shell and file tools inside your sandboxes. A worker can be started with the ant beta:worker command or built with the SDKs. Each agent session gets a sandbox container of its own, so one session’s work cannot leak into another’s. The sandboxes are where code actually executes — the builds, the tests, the file edits — and they are disposable by design. Anthropic’s architecture notes that an agent does not depend on one sandbox surviving its whole run, and sandboxes start only when a tool needs them.

For a quick trial, Anthropic’s quickstart runs the whole stack on one machine with Docker Compose: the server, its PostgreSQL database, and a set of workers, each session in a sandbox container of its own. The requirements are modest — the latest Docker Engine with the Compose plugin, a host with at least two CPUs (x86-64 or Arm), a Claude API key, the ant CLI and openssl. Network access is needed on first start because the build pulls from Docker Hub, the Alpine package repositories and GitHub releases.

Anthropic is explicit that the Compose stack serves plain HTTP and is for development only, not production. It also warns that Docker Engine releases before 28.3.3 can expose the loopback-published port on the local network, and that agent tools run in containers on the host, so the trial machine should not hold anything that must stay protected.

Developer building agents with self-hosted Claude Managed Agents in a dark code editor

The console and the admin CLI

The remaining pieces make the deployment operable. The release includes a web console served from the server’s own address, where people sign in through the company’s identity provider to create agents and run sessions — single sign-on is one of the features that only exists on the self-hosted server. There is also an admin CLI, cma-server-admin, that creates environments and environment keys, running on Linux (x86-64 and Arm) and on macOS with Apple silicon.

Three credentials keep the layers separate. The server API key authenticates applications, the ant CLI and the admin CLI against your self-hosted server, playing the role a Claude API key plays with the hosted service. A separate inference credential is what the server uses to call your model provider. And an environment key per work queue authenticates workers. The server reads its settings from a single YAML file, with environment variables able to override it, and unknown keys stop startup — a small detail, but one that tells you Anthropic expects configuration mistakes to fail loudly rather than silently.

What Stays Outside Your Walls: The Model Question

Here is the part that trips people up, so it is worth stating twice: self-hosted Claude Managed Agents does not move the model. “The model runs at Anthropic or at a provider that you choose,” the documentation says. Every time the agent needs to think — to decide the next tool call, to interpret a result, to draft a patch — your server sends a request out to a model provider, and that request carries the conversation so far, including tool inputs and results. Your code, your file contents and your tool outputs still cross the network to the model. What stays home is the orchestration and the storage, not the reasoning.

That is not a flaw in the product; it is the product’s stated boundary, and understanding it is the difference between a deployment that satisfies your security review and one that fails it halfway through. If your requirement is that no source code ever leaves your network, self-hosted Claude Managed Agents does not meet it. If your requirement is that session history, credentials and the agent control plane live on your infrastructure, and that you choose which provider processes the model calls, it does.

The choice of provider is a real one, and it is wider than most people expect. The server’s inference.provider setting accepts five values:

  • anthropic — the default. Model calls go to the Claude API directly, exactly as they do for the hosted service.
  • bedrock — Claude through Amazon Bedrock, which suits teams already committed to AWS, with their Bedrock contracts, controls and billing.
  • vertex — Claude models on Google Cloud, for teams standardised on Google’s platform.
  • foundry — Microsoft Foundry, for teams in the Microsoft ecosystem.
  • gateway — your own model gateway, for teams that route all model traffic through an internal proxy for logging, policy or cost control.

That list is doing quiet strategic work. A bank that has a multi-year AWS commitment can point its agents at Bedrock and keep the spend inside that commitment. A company with a data-processing agreement covering Google Cloud can keep model traffic inside it. A team with a strict egress proxy can force everything through its own gateway. The provider choice is also the main reason the self-hosted option exists for organisations that could never use the hosted service for contractual reasons: the model call can go wherever their contracts already allow it to go.

One more detail from the announcement is worth noting for privacy teams. Session history is stored in your own database, and if your organisation has zero data retention (ZDR) in place with Anthropic, it applies to the requests sent to Claude in the same way as any other Messages API call. ZDR does not change where history is stored — that is already yours — but it governs what Anthropic retains from the model calls themselves. If you are in a regulated industry, that sentence is one to put in front of your legal team early.

Three Ways to Host Claude Managed Agents, Compared

Anthropic now offers three hosting arrangements, and the difference between them is simply which of three layers you operate: the sandboxes, the service, and the model. The documentation frames the choice that way, and it is the clearest lens for deciding which row fits your organisation.

Option Sandboxes Service and storage Model
Hosted Managed Agents (since April 2026) Anthropic Anthropic Anthropic
Self-hosted sandboxes (since May 2026) You Anthropic Anthropic
Self-hosted Claude Managed Agents (since 12 November 2026) You You Anthropic, or a provider you choose

The middle row is the one most teams should consider first, and Anthropic’s own guidance says so. If your only requirement is that agent tools run inside your network — that the code execution happens on your machines, behind your firewall — the self-hosted sandboxes option already does that, while Anthropic still runs the service, the history and the credentials. You get the network control without operating a server, a database and a worker fleet. The documentation points teams with only that need back to self-hosted sandboxes rather than to the full self-hosted service.

The third row is for two specific situations, and Anthropic names them explicitly. The first is storage: you must store agents, sessions and session history yourself, on your own infrastructure, under your own retention rules. The second is model routing: model calls must go to a specific inference provider, such as Bedrock or Foundry, rather than to Anthropic directly. If neither of those applies to you, the full self-hosted option is extra operational work for no benefit. If either applies, nothing else in Anthropic’s lineup solves it.

The trade of self-hosted Claude Managed Agents is stated just as explicitly in the documentation: “you run and secure a server, its database, and your sandboxes, and you install each release yourself.” That is the whole deal in one sentence. Anthropic hands you the control plane; you take on the patching, the upgrades, the database backups, the sandbox runtime security and the incident response. A team that cannot staff that work will end up less secure than it was on the hosted service, not more. The hosted service has Anthropic’s security team watching it around the clock. Your self-hosted server has whoever you assign to it.

Technician maintaining server racks where self-hosted Claude Managed Agents sandboxes run

Designed for Agent Security: The Four Principles

Anthropic’s announcement spends most of its space not on the self-hosting mechanics but on the security architecture underneath them, and that emphasis is deliberate. The argument is that agent security cannot depend on a person checking every step, because the whole point of an agent is that it works unattended. So the limits have to be built into the system itself. Managed Agents — including self-hosted Claude Managed Agents — is designed around four principles, and Anthropic says they apply whether it hosts everything, you host just the sandbox, or you host the whole service. They are worth understanding because they are also the checklist your security team will use to judge the product.

1. The brain and the hands are split

The harness (the brain) calls Claude, and the sandbox (the hands) is where the agent’s code runs, and the two are kept separate by design. The agent’s code runs in the sandbox, while the agent loop, the session history and the vault secrets stay outside it. That separation buys three things. First, an agent does not depend on one sandbox surviving its whole run, so a crashed or compromised sandbox does not take the session with it. Second, sandboxes start only when a tool needs them, so there is no long-lived execution environment sitting around waiting to be attacked.

Third, the session history lives outside the sandbox as an event log, so even a fully compromised sandbox cannot rewrite the record of what happened. For a security reviewer, this is the most important principle: the blast radius of a bad tool call is the sandbox, not the control plane.

2. Credentials stay out of the sandbox

Vaults are designed to keep credentials out of the sandbox entirely. For MCP tools and supported API calls, a proxy outside the sandbox adds the credential to the request, so the agent can use a credential without ever seeing it. The agent can ask for an API call to be made, but it cannot read the token, copy it, print it, or paste it into a file.

With self-hosted Claude Managed Agents, you can also store credentials in your own secrets manager instead of Anthropic’s vault, which is one of the four features that only exist on the self-hosted server. That matters because the most common way an agent gets turned against its owner is through its credentials: a prompt injection in a document the agent reads tells it to exfiltrate a token, and if the token was never in the sandbox, there is nothing to exfiltrate. No design can make that risk zero — the agent can still ask the proxy to make calls on its behalf — but keeping the raw secret out of the agent’s reach removes the simplest attack.

3. Network access can be limited

Each environment can be limited to a list of allowed hosts, and requests to any other host are blocked. For an agent that fixes broken builds, that list might be just your git host and your package registry — nothing else. An agent that can only reach two hosts cannot phone home to an attacker’s server, cannot download a malicious payload from a random domain, and cannot probe your internal network beyond what you listed.

When you host the sandbox yourself, you set the same limits in your own firewall, so the allowlist and the network policy reinforce each other. This is the principle that turns the sandbox from a container into a boundary, and it is the one most teams underuse: the default should be the smallest host list that lets the agent do its job, not the widest list that avoids an error.

4. Every session leaves a full record

Managed Agents keeps a record of every step an agent took, including the tool calls it made and what came back. The record exports over OpenTelemetry, so you can send it to the monitoring tools you already use and review agent activity alongside the rest of your systems. That sounds administrative until you imagine the incident it exists for: an agent changed something in production at 3 a.m., nobody was watching, and the first question in the morning is what it did, in what order, and why. With a full session record, you can answer that. Without one, you are guessing.

In the self-hosted deployment, that record lives in your PostgreSQL database, which means your existing log retention, audit and alerting pipelines can consume it directly. Anthropic’s point is that auditability is not a feature you add after an incident; it is a property of the architecture.

These four principles are not new to the self-hosted release — they describe the whole Managed Agents platform. What the self-hosted release changes is where they are enforced. On the hosted service, Anthropic enforces them. On self-hosted Claude Managed Agents, you enforce them, with your own firewall rules, your own secrets manager and your own database. The principles stay the same; the operator changes. That is the honest way to read the announcement: it is not claiming the self-hosted version is more secure by magic. It is claiming that the security architecture was designed to be operable by someone other than Anthropic, and now it is.

What You Give Up in the Self-Hosted Version

No honest guide to self-hosted Claude Managed Agents can skip this section, because the differences page in Anthropic’s documentation is long and specific. The self-hosted Claude Managed Agents server is not a feature-for-feature copy of the hosted service. Anthropic’s differences page lists the gap in three tables: four features that only the self-hosted server has, seven hosted features that are not available at all on the self-hosted server, and fourteen features that behave differently. If you are evaluating this for a real deployment, the differences page is the document to read in full. Here are the trade-offs that matter most.

What only the self-hosted server has: a choice of inference provider, single sign-on through your identity provider, your own secrets manager for credentials, and agent identity — the ability to give agents identities inside your own systems rather than Anthropic’s. Those four are the reason to self-host, and they are all about control: who the model call goes to, who signs in, where the secrets live, and who the agent is when it knocks on your internal doors.

What is not available at all: the list includes webhooks, scheduled deployments, dynamic workflows, the Files API, and MCP OAuth credentials, along with cloud environments and the Messages, Models and Files APIs. Two of those deserve a closer look. Dynamic workflows — the feature that lets one lead agent write its own orchestration program and run up to 1,000 subagents — is unavailable on the self-hosted server, which is a real loss for teams that were planning large-scale multi-agent work. We covered dynamic workflows in our guide to Claude Flows and dynamic workflows, and the contrast is sharp: the hosted service can fan out to a thousand agents, the self-hosted server cannot, at least in this beta.

Scheduled deployments are also out, so agents that run on a timetable — the nightly triage run, the weekly dependency sweep — need an external scheduler to trigger them instead.

What behaves differently: fourteen features, including web search and fetch, which stay off until explicitly enabled; MCP servers and Git repositories, which need host allowlists before they work; and the upgrade path itself, which is manual — you install each release. The Docker Compose setup is for development only, not production, and production means Kubernetes 1.30 or later, with the Agent Sandbox controller and a network plugin that enforces NetworkPolicy, nodes with a sandboxed container runtime (the guide uses gVisor on Google and Amazon clusters and Pod Sandboxing on Azure), a container registry you operate yourself, and cluster-admin rights. Anthropic ships no container images; you build the cma-server, dispatcher and sandbox images yourself.

Read as a whole, the gap tells you who the self-hosted Claude Managed Agents beta is for. It is for teams whose requirement is control of the service, the storage and the credentials, and who can live without the newest hosted features while the self-hosted version catches up. It is not for teams that want the fullest Claude agent platform. Those teams should stay on the hosted service. Anthropic is not hiding that; the differences page exists precisely so that buyers can make the comparison before they commit.

Who Should Self-Host — and Who Should Not

The honest answer is that most teams should not run self-hosted Claude Managed Agents, and Anthropic’s own guidance agrees. The hosted service is simpler, cheaper to operate, more feature-complete, and watched over by Anthropic’s security team. Self-hosting is the right call for a narrower set of organisations, and they tend to share one of three characteristics.

You should ask for access if you are in a regulated industry — banking, healthcare, government, defence-adjacent work — where session history and credentials must live on infrastructure you control, and your compliance team has already told you the hosted service is not acceptable. Or if your model traffic must go to a specific provider because of a cloud commitment, a data-processing agreement or an egress policy, and the hosted service’s direct-to-Anthropic routing breaks that rule. Or if your security architecture requires agents to have identities in your own identity system and credentials in your own secrets manager, which only the self-hosted server supports.

You should stay on the hosted service if your main concern is that agent code runs inside your network, because self-hosted sandboxes already solve that without the operational burden. Or if you need dynamic workflows, scheduled deployments or webhooks, which the self-hosted beta does not have. Or if your team has no one to own a Kubernetes deployment, a PostgreSQL database and a release-upgrade cycle — because an unpatched, unmonitored self-hosted agent server is a worse security posture than the hosted service, not a better one. The control you gain is only as good as the operations behind it.

You should wait if you are a small team that likes the idea but has no hard compliance requirement. The private beta will become a public offering eventually, the feature gap will narrow, and the documentation will grow. There is no prize for being first into a private beta you cannot operate. The right time to self-host is when a specific requirement forces the decision, not when the announcement is fresh.

Enterprise team planning a self-hosted Claude Managed Agents deployment around laptops

How to Get Access to the Private Beta

There is no self-service path into the private beta. Access runs through your Anthropic account team: you contact them, request the release archive, and they decide whether your organisation is eligible. Anthropic has published no eligibility criteria, no covered-countries list and no general-availability date, so the honest answer to “can I get it?” is that it depends on your existing relationship with Anthropic. Organisations with an enterprise agreement and an account team are the ones who will get in first. Everyone else should read the documentation and prepare, rather than expect immediate access.

If you do get the self-hosted Claude Managed Agents release archive, the documented path starts with the quickstart, and it is deliberately small.

You need the release archive itself, a Claude API key created in the Claude Console (the server uses it for model calls), the latest Docker Engine with the Compose plugin, a host with at least two CPUs, network access on first start, and the openssl and ant CLI tools on the machine where you run Docker. The quickstart names its environment compose-sandbox and runs the server, the database and the workers on one machine. If your umask is stricter than 022, the binaries lose their execute permission for other users and the server container cannot start them — the docs tell you to set it to 022 and extract the archive again.

Details like that are a good sign: they mean the quickstart has actually been run by real teams and the sharp edges documented.

The console needs single sign-on to try, and the quickstart lets you restart the stack with a mock sign-in provider, with port 8080 free on your machine. Server settings live in a YAML file — edit compose.config.oidc.yaml when SSO is involved, not compose.config.yaml — then restart with docker compose restart cma-server. None of this is production configuration. Production is the Kubernetes route described above, with the two Helm charts, a separately provisioned PostgreSQL 16 or later database, a container registry, and images you build yourself. Budget real engineering time for that step; the quickstart is an afternoon, the production deployment is a project.

One operational note that deserves emphasis: agents, skills, vault credentials, memory stores and session history all have to be created again on your server. There is no migration from the hosted service. Your self-hosted deployment starts empty. If your team has built up agents, skills and history on the hosted platform, moving to self-hosted means rebuilding that state. That is a cost to factor into the decision, and a reason to choose your hosting model early rather than migrate later. It is also worth checking that your team is comfortable with the ant CLI and the Managed Agents API before committing, since those are the same on both, and familiarity there transfers directly.

Pricing: What Self-Hosted Claude Managed Agents Costs

Anthropic has published no price for the self-hosted version. The pricing page directs you to contact your Anthropic account team, which is the same channel as access itself. That is not unusual for enterprise infrastructure in private beta — the price will depend on your organisation, your usage and your existing agreement — but it means any article that quotes a self-hosted price today is guessing. We will not guess.

What we do know is the hosted price, which is the baseline to compare against. The hosted Managed Agents service lists tokens at model rates plus $0.08 per session-hour. A session-hour is an hour of an agent session running, and the $0.08 covers the harness, the sandboxes, the credential handling and the history that Anthropic operates for you. On top of that you pay the model tokens the agent consumes, at the normal Claude API rates for the model you choose.

On the self-hosted Claude Managed Agents side, the cost structure changes shape. You still pay for model tokens — the calls go to Anthropic, Bedrock, Vertex, Foundry or your gateway, and whoever serves them charges you — but the $0.08 per session-hour for the platform is replaced by your own infrastructure and operations cost: the compute for cma-server, the PostgreSQL database, the worker nodes and the sandbox runtime, plus the engineering time to run, patch and upgrade it all.

For a large organisation already running Kubernetes, that marginal cost may be small. For a smaller team, it will almost certainly exceed $0.08 per session-hour once staff time is counted. That is the real pricing question to model before you ask for access: not the licence fee, which is unpublished, but the total cost of operating the platform yourself versus the hosted per-session-hour rate.

There is also a subtle cost in the feature gap. If your workflow depends on dynamic workflows or scheduled deployments, replacing them on the self-hosted server means building or buying that capability elsewhere, and that work has a price too. The cheapest deployment is usually the one that needs the least compensating engineering, and for most teams that is still the hosted service.

Self-Hosted Claude Managed Agents vs the Competition

Anthropic is not the only vendor moving agent infrastructure inside the customer’s perimeter, and the week of the announcement makes the race visible. Google’s Gemini API gained self-hosted sandboxes on 11 November, one day before Anthropic’s announcement — but note the difference in scope. Google moved the sandbox, the place where agent code runs. Anthropic moved the whole service, including the API, the agent loop and the storage. Anthropic’s self-hosted sandboxes already existed since May, so the November release is a step beyond what Google announced, not a catch-up to it.

That said, Google’s move shows the direction of travel: every major agent platform now accepts that enterprise buyers will ask where the agent’s execution and history live, and each vendor is answering in its own way.

OpenAI’s position is different again. Its agent products — including the Codex family — remain hosted services, and its enterprise pitch leans on data controls inside its own cloud rather than on letting customers run the service. We covered OpenAI’s Codex Security scanner in our guide to OpenAI Codex Security, and the contrast is instructive: OpenAI is building agent tools you run against its platform, while Anthropic is building a platform you can run yourself.

Neither approach is universally better; they optimise for different buyers. A team that wants the lowest operational burden picks the hosted route, whichever vendor offers it. A team that needs the control plane on its own infrastructure now has exactly one vendor offering it for a frontier agent platform, and that is Anthropic.

The open-weight world offers a third path. Models like the open agent frameworks and self-hosted coding agents give you full control, including the model itself, but you assemble the harness, the sandboxes, the credentials and the history yourself, and you give up frontier-model capability. Self-hosted Claude Managed Agents sits between those two poles: a vendor-built, frontier-model platform that you operate. That middle position is its real selling point, and also its real limitation — you get the vendor’s engineering, but you still depend on the vendor’s model, and you still pay the vendor’s token rates.

For teams evaluating all three, the decision framework is simple. If model capability matters most and operational burden matters least, use a hosted frontier service. If control of the model itself matters most, go open-weight and accept the capability trade. If you need frontier capability with control of the service, the storage and the credentials — but can accept that the model call still leaves the building — self-hosted Claude Managed Agents is the option built for you. Almost nobody else is offering that combination today.

Engineer monitoring self-hosted Claude Managed Agents infrastructure with a laptop in a server room

The Bigger Picture: Agents Are Moving Inside the Perimeter

Step back from the product details and the announcement fits a story that has been building all autumn. AI agents are colliding with the boundaries of the organisations that want to use them, and the collision is happening on two fronts at once. On one front, outside companies are blocking agents: Yelp, Delta, JPMorgan Chase and Charles Schwab have all moved to keep agents from OpenAI, Meta, xAI and others off their platforms, as we explained in our article on why websites are blocking AI agents.

On the other front, inside companies, security teams are asking where agents live and who watches them. The two stories are the same story told from opposite sides of the firewall: agents are powerful enough now that nobody is comfortable letting them roam free, whether they are coming in from outside or running loose inside.

Self-hosted Claude Managed Agents is Anthropic’s answer to the inside half of that story. It does not resolve the outside half — your agents still need to interact with external services, and those services may still block them — but it gives the internal security team something concrete: the control plane on their infrastructure, the history in their database, the credentials in their secrets manager, the network allowlist in their firewall. That is a meaningful answer to the question “who is responsible for this agent?”, and it is the question every enterprise agent deployment eventually has to answer.

There is also a longer-term shift worth naming. When a platform vendor ships a self-hosted version of its service, it is conceding that the cloud is not the right home for every workload. That concession used to be rare for AI products, which were almost all cloud-only by design. Anthropic’s move suggests the agent era will look more like the database era than the chatbot era: the same product, offered hosted for convenience and self-hosted for control, with the customer choosing per workload. If that pattern holds, expect the other vendors to follow with their own self-hosted agent services, and expect the comparison between them — features, gaps, pricing — to become a standard part of enterprise AI procurement.

For now, though, the practical reality is narrower. Self-hosted Claude Managed Agents is a private beta, eight days old at the time of writing, with no public price, no general-availability date, and a feature list that is deliberately shorter than the hosted service. The teams that should care about it today are the ones with a concrete compliance or contractual reason to bring the agent service in-house. Everyone else can watch the beta, read the documentation, and keep building on the hosted service — which is, after all, the same APIs, the same agent loop, and the same Claude models, without the Kubernetes cluster.

Frequently Asked Questions

Is self-hosted Claude Managed Agents the same as running Claude offline?

No. Self-hosted Claude Managed Agents runs the agent service — the API, the agent loop, the storage, the credentials and the sandboxes — on your infrastructure, but every model call still goes to Anthropic or to a provider you choose, such as Amazon Bedrock, Google Cloud, Microsoft Foundry or your own gateway. Your code and tool outputs still cross the network to the model. If you need a fully offline model, you need an open-weight model running locally, not this product.

How much does self-hosted Claude Managed Agents cost?

Anthropic has published no price for the self-hosted version; pricing goes through your Anthropic account team. For comparison, the hosted Managed Agents service costs $0.08 per session-hour plus model tokens at Claude API rates. On the self-hosted side you still pay for model tokens, and you replace the $0.08 platform fee with your own infrastructure and operations costs — compute, database, workers and engineering time.

What is the difference between self-hosted sandboxes and self-hosted Claude Managed Agents?

Self-hosted sandboxes, available since May 2026, move only the execution environment to your infrastructure: agent code runs in your containers, but Anthropic still runs the service, the session history and the credentials. Self-hosted Claude Managed Agents, launched 12 November 2026, moves the whole service as well — the server, the database and the workers — so the API, the agent loop and all stored history live on your infrastructure too.

Which hosted features are missing from the self-hosted version?

According to Anthropic’s differences page, webhooks, scheduled deployments, dynamic workflows, the Files API and MCP OAuth credentials are unavailable, along with cloud environments and the Messages, Models and Files APIs. Fourteen other features behave differently, including web search and fetch, which stay off until explicitly enabled. The self-hosted server gains four features the hosted service lacks: a choice of inference provider, single sign-on, your own secrets manager, and agent identity.

What do I need to run self-hosted Claude Managed Agents?

For a trial, the Docker Compose quickstart needs the release archive (from your Anthropic account team), a Claude API key, the latest Docker Engine with the Compose plugin, a host with at least two CPUs, and the openssl and ant CLI tools. For production, Anthropic recommends Kubernetes 1.30 or later with the two Helm charts in the release archive, a PostgreSQL 16 or later database provisioned separately, a container registry, and images you build yourself.

How do I get access to the private beta?

Contact your Anthropic account team and request access to the release archive. There is no public signup page, no published eligibility criteria and no general-availability date. Organisations with an existing enterprise relationship with Anthropic are the most likely to be admitted first.

The Bottom Line

Self-hosted Claude Managed Agents is a significant release, but it is a narrow one, and understanding the narrowness is the key to using it well. It lets companies run Anthropic’s entire agent service — the server, the database, the workers, the credentials and the session history — inside their own cloud or data centre, while choosing where model calls go: Anthropic directly, Amazon Bedrock, Google Cloud, Microsoft Foundry, or their own gateway.

It is built on four sound security principles — the brain and the hands are split, credentials stay out of the sandbox, network access is allowlisted, and every session leaves a full record — and it is aimed squarely at regulated, compliance-driven organisations that cannot put their agent control plane on someone else’s infrastructure.

What it is not matters just as much. It is not Claude running on your servers, it is not offline, and it is not a feature-for-feature copy of the hosted service: dynamic workflows, scheduled deployments, webhooks and several other hosted features are missing in this beta, and there is no public price or general-availability date. The hosted service remains the right choice for most teams, and self-hosted sandboxes already cover the teams whose only need is to run agent code inside their own network.

If you have a concrete reason — a compliance requirement, a cloud commitment, a data-processing agreement — that forces the agent service onto your infrastructure, ask your Anthropic account team for access, read the differences page in full, and budget real engineering time for the Kubernetes deployment. If you do not have that reason, keep building on the hosted service and watch the beta mature. Either way, the direction is clear: agents are moving inside the perimeter, and the vendors that let you choose where they live are the ones enterprise buyers will take seriously. Self-hosted Claude Managed Agents is Anthropic’s bid for that trust, and for the teams it is built for, it is a genuine step forward.

Leave a Comment

Your email address will not be published. Required fields are marked *